libstdc++-v3/include/std/complex

   1 // The template and inlines for the -*- C++ -*- complex number classes.
   2
   3 // Copyright (C) 1997-2018 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() const { return _M_real; }
 148
 149       _GLIBCXX_ABI_TAG_CXX11
 150       constexpr _Tp
 151       imag() const { 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       bool __fail = true;
 496       _CharT __ch;
 497       if (__is >> __ch)
 498         {
 499           if (_Traits::eq(__ch, __is.widen('(')))
 500             {
 501               _Tp __u;
 502               if (__is >> __u >> __ch)
 503                 {
 504                   const _CharT __rparen = __is.widen(')');
 505                   if (_Traits::eq(__ch, __rparen))
 506                     {
 507                       __x = __u;
 508                       __fail = false;
 509                     }
 510                   else if (_Traits::eq(__ch, __is.widen(',')))
 511                     {
 512                       _Tp __v;
 513                       if (__is >> __v >> __ch)
 514                         {
 515                           if (_Traits::eq(__ch, __rparen))
 516                             {
 517                               __x = complex<_Tp>(__u, __v);
 518                               __fail = false;
 519                             }
 520                           else
 521                             __is.putback(__ch);
 522                         }
 523                     }
 524                   else
 525                     __is.putback(__ch);
 526                 }
 527             }
 528           else
 529             {
 530               __is.putback(__ch);
 531               _Tp __u;
 532               if (__is >> __u)
 533                 {
 534                   __x = __u;
 535                   __fail = false;
 536                 }
 537             }
 538         }
 539       if (__fail)
 540         __is.setstate(ios_base::failbit);
 541       return __is;
 542     }
 543
 544   ///  Insertion operator for complex values.
 545   template<typename _Tp, typename _CharT, class _Traits>
 546     basic_ostream<_CharT, _Traits>&
 547     operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
 548     {
 549       basic_ostringstream<_CharT, _Traits> __s;
 550       __s.flags(__os.flags());
 551       __s.imbue(__os.getloc());
 552       __s.precision(__os.precision());
 553       __s << '(' << __x.real() << ',' << __x.imag() << ')';
 554       return __os << __s.str();
 555     }
 556
 557   // Values
 558 #if __cplusplus >= 201103L
 559   template<typename _Tp>
 560     constexpr _Tp
 561     real(const complex<_Tp>& __z)
 562     { return __z.real(); }
 563
 564   template<typename _Tp>
 565     constexpr _Tp
 566     imag(const complex<_Tp>& __z)
 567     { return __z.imag(); }
 568 #else
 569   template<typename _Tp>
 570     inline _Tp&
 571     real(complex<_Tp>& __z)
 572     { return __z.real(); }
 573
 574   template<typename _Tp>
 575     inline const _Tp&
 576     real(const complex<_Tp>& __z)
 577     { return __z.real(); }
 578
 579   template<typename _Tp>
 580     inline _Tp&
 581     imag(complex<_Tp>& __z)
 582     { return __z.imag(); }
 583
 584   template<typename _Tp>
 585     inline const _Tp&
 586     imag(const complex<_Tp>& __z)
 587     { return __z.imag(); }
 588 #endif
 589
 590   // 26.2.7/3 abs(__z):  Returns the magnitude of __z.
 591   template<typename _Tp>
 592     inline _Tp
 593     __complex_abs(const complex<_Tp>& __z)
 594     {
 595       _Tp __x = __z.real();
 596       _Tp __y = __z.imag();
 597       const _Tp __s = std::max(abs(__x), abs(__y));
 598       if (__s == _Tp())  // well ...
 599         return __s;
 600       __x /= __s;
 601       __y /= __s;
 602       return __s * sqrt(__x * __x + __y * __y);
 603     }
 604
 605 #if _GLIBCXX_USE_C99_COMPLEX
 606   inline float
 607   __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
 608
 609   inline double
 610   __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
 611
 612   inline long double
 613   __complex_abs(const __complex__ long double& __z)
 614   { return __builtin_cabsl(__z); }
 615
 616   template<typename _Tp>
 617     inline _Tp
 618     abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
 619 #else
 620   template<typename _Tp>
 621     inline _Tp
 622     abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
 623 #endif
 624
 625
 626   // 26.2.7/4: arg(__z): Returns the phase angle of __z.
 627   template<typename _Tp>
 628     inline _Tp
 629     __complex_arg(const complex<_Tp>& __z)
 630     { return  atan2(__z.imag(), __z.real()); }
 631
 632 #if _GLIBCXX_USE_C99_COMPLEX
 633   inline float
 634   __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
 635
 636   inline double
 637   __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
 638
 639   inline long double
 640   __complex_arg(const __complex__ long double& __z)
 641   { return __builtin_cargl(__z); }
 642
 643   template<typename _Tp>
 644     inline _Tp
 645     arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
 646 #else
 647   template<typename _Tp>
 648     inline _Tp
 649     arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
 650 #endif
 651
 652   // 26.2.7/5: norm(__z) returns the squared magnitude of __z.
 653   //     As defined, norm() is -not- a norm is the common mathematical
 654   //     sense used in numerics.  The helper class _Norm_helper<> tries to
 655   //     distinguish between builtin floating point and the rest, so as
 656   //     to deliver an answer as close as possible to the real value.
 657   template<bool>
 658     struct _Norm_helper
 659     {
 660       template<typename _Tp>
 661         static inline _Tp _S_do_it(const complex<_Tp>& __z)
 662         {
 663           const _Tp __x = __z.real();
 664           const _Tp __y = __z.imag();
 665           return __x * __x + __y * __y;
 666         }
 667     };
 668
 669   template<>
 670     struct _Norm_helper<true>
 671     {
 672       template<typename _Tp>
 673         static inline _Tp _S_do_it(const complex<_Tp>& __z)
 674         {
 675           _Tp __res = std::abs(__z);
 676           return __res * __res;
 677         }
 678     };
 679
 680   template<typename _Tp>
 681     inline _Tp
 682     norm(const complex<_Tp>& __z)
 683     {
 684       return _Norm_helper<__is_floating<_Tp>::__value
 685         && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
 686     }
 687
 688   template<typename _Tp>
 689     inline complex<_Tp>
 690     polar(const _Tp& __rho, const _Tp& __theta)
 691     {
 692       __glibcxx_assert( __rho >= 0 );
 693       return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta));
 694     }
 695
 696   template<typename _Tp>
 697     inline complex<_Tp>
 698     conj(const complex<_Tp>& __z)
 699     { return complex<_Tp>(__z.real(), -__z.imag()); }
 700
 701   // Transcendentals
 702
 703   // 26.2.8/1 cos(__z):  Returns the cosine of __z.
 704   template<typename _Tp>
 705     inline complex<_Tp>
 706     __complex_cos(const complex<_Tp>& __z)
 707     {
 708       const _Tp __x = __z.real();
 709       const _Tp __y = __z.imag();
 710       return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
 711     }
 712
 713 #if _GLIBCXX_USE_C99_COMPLEX
 714   inline __complex__ float
 715   __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
 716
 717   inline __complex__ double
 718   __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
 719
 720   inline __complex__ long double
 721   __complex_cos(const __complex__ long double& __z)
 722   { return __builtin_ccosl(__z); }
 723
 724   template<typename _Tp>
 725     inline complex<_Tp>
 726     cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
 727 #else
 728   template<typename _Tp>
 729     inline complex<_Tp>
 730     cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
 731 #endif
 732
 733   // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
 734   template<typename _Tp>
 735     inline complex<_Tp>
 736     __complex_cosh(const complex<_Tp>& __z)
 737     {
 738       const _Tp __x = __z.real();
 739       const _Tp __y = __z.imag();
 740       return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
 741     }
 742
 743 #if _GLIBCXX_USE_C99_COMPLEX
 744   inline __complex__ float
 745   __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
 746
 747   inline __complex__ double
 748   __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
 749
 750   inline __complex__ long double
 751   __complex_cosh(const __complex__ long double& __z)
 752   { return __builtin_ccoshl(__z); }
 753
 754   template<typename _Tp>
 755     inline complex<_Tp>
 756     cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
 757 #else
 758   template<typename _Tp>
 759     inline complex<_Tp>
 760     cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
 761 #endif
 762
 763   // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
 764   template<typename _Tp>
 765     inline complex<_Tp>
 766     __complex_exp(const complex<_Tp>& __z)
 767     { return std::polar<_Tp>(exp(__z.real()), __z.imag()); }
 768
 769 #if _GLIBCXX_USE_C99_COMPLEX
 770   inline __complex__ float
 771   __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
 772
 773   inline __complex__ double
 774   __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
 775
 776   inline __complex__ long double
 777   __complex_exp(const __complex__ long double& __z)
 778   { return __builtin_cexpl(__z); }
 779
 780   template<typename _Tp>
 781     inline complex<_Tp>
 782     exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
 783 #else
 784   template<typename _Tp>
 785     inline complex<_Tp>
 786     exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
 787 #endif
 788
 789   // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z.
 790   //                    The branch cut is along the negative axis.
 791   template<typename _Tp>
 792     inline complex<_Tp>
 793     __complex_log(const complex<_Tp>& __z)
 794     { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
 795
 796 #if _GLIBCXX_USE_C99_COMPLEX
 797   inline __complex__ float
 798   __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
 799
 800   inline __complex__ double
 801   __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
 802
 803   inline __complex__ long double
 804   __complex_log(const __complex__ long double& __z)
 805   { return __builtin_clogl(__z); }
 806
 807   template<typename _Tp>
 808     inline complex<_Tp>
 809     log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
 810 #else
 811   template<typename _Tp>
 812     inline complex<_Tp>
 813     log(const complex<_Tp>& __z) { return __complex_log(__z); }
 814 #endif
 815
 816   template<typename _Tp>
 817     inline complex<_Tp>
 818     log10(const complex<_Tp>& __z)
 819     { return std::log(__z) / log(_Tp(10.0)); }
 820
 821   // 26.2.8/10 sin(__z): Returns the sine of __z.
 822   template<typename _Tp>
 823     inline complex<_Tp>
 824     __complex_sin(const complex<_Tp>& __z)
 825     {
 826       const _Tp __x = __z.real();
 827       const _Tp __y = __z.imag();
 828       return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
 829     }
 830
 831 #if _GLIBCXX_USE_C99_COMPLEX
 832   inline __complex__ float
 833   __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
 834
 835   inline __complex__ double
 836   __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
 837
 838   inline __complex__ long double
 839   __complex_sin(const __complex__ long double& __z)
 840   { return __builtin_csinl(__z); }
 841
 842   template<typename _Tp>
 843     inline complex<_Tp>
 844     sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
 845 #else
 846   template<typename _Tp>
 847     inline complex<_Tp>
 848     sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
 849 #endif
 850
 851   // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
 852   template<typename _Tp>
 853     inline complex<_Tp>
 854     __complex_sinh(const complex<_Tp>& __z)
 855     {
 856       const _Tp __x = __z.real();
 857       const _Tp  __y = __z.imag();
 858       return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
 859     }
 860
 861 #if _GLIBCXX_USE_C99_COMPLEX
 862   inline __complex__ float
 863   __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
 864
 865   inline __complex__ double
 866   __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
 867
 868   inline __complex__ long double
 869   __complex_sinh(const __complex__ long double& __z)
 870   { return __builtin_csinhl(__z); }
 871
 872   template<typename _Tp>
 873     inline complex<_Tp>
 874     sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
 875 #else
 876   template<typename _Tp>
 877     inline complex<_Tp>
 878     sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
 879 #endif
 880
 881   // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
 882   //                     The branch cut is on the negative axis.
 883   template<typename _Tp>
 884     complex<_Tp>
 885     __complex_sqrt(const complex<_Tp>& __z)
 886     {
 887       _Tp __x = __z.real();
 888       _Tp __y = __z.imag();
 889
 890       if (__x == _Tp())
 891         {
 892           _Tp __t = sqrt(abs(__y) / 2);
 893           return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
 894         }
 895       else
 896         {
 897           _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
 898           _Tp __u = __t / 2;
 899           return __x > _Tp()
 900             ? complex<_Tp>(__u, __y / __t)
 901             : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
 902         }
 903     }
 904
 905 #if _GLIBCXX_USE_C99_COMPLEX
 906   inline __complex__ float
 907   __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
 908
 909   inline __complex__ double
 910   __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
 911
 912   inline __complex__ long double
 913   __complex_sqrt(const __complex__ long double& __z)
 914   { return __builtin_csqrtl(__z); }
 915
 916   template<typename _Tp>
 917     inline complex<_Tp>
 918     sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
 919 #else
 920   template<typename _Tp>
 921     inline complex<_Tp>
 922     sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
 923 #endif
 924
 925   // 26.2.8/14 tan(__z):  Return the complex tangent of __z.
 926
 927   template<typename _Tp>
 928     inline complex<_Tp>
 929     __complex_tan(const complex<_Tp>& __z)
 930     { return std::sin(__z) / std::cos(__z); }
 931
 932 #if _GLIBCXX_USE_C99_COMPLEX
 933   inline __complex__ float
 934   __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
 935
 936   inline __complex__ double
 937   __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
 938
 939   inline __complex__ long double
 940   __complex_tan(const __complex__ long double& __z)
 941   { return __builtin_ctanl(__z); }
 942
 943   template<typename _Tp>
 944     inline complex<_Tp>
 945     tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
 946 #else
 947   template<typename _Tp>
 948     inline complex<_Tp>
 949     tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
 950 #endif
 951
 952
 953   // 26.2.8/15 tanh(__z):  Returns the hyperbolic tangent of __z.
 954
 955   template<typename _Tp>
 956     inline complex<_Tp>
 957     __complex_tanh(const complex<_Tp>& __z)
 958     { return std::sinh(__z) / std::cosh(__z); }
 959
 960 #if _GLIBCXX_USE_C99_COMPLEX
 961   inline __complex__ float
 962   __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
 963
 964   inline __complex__ double
 965   __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
 966
 967   inline __complex__ long double
 968   __complex_tanh(const __complex__ long double& __z)
 969   { return __builtin_ctanhl(__z); }
 970
 971   template<typename _Tp>
 972     inline complex<_Tp>
 973     tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
 974 #else
 975   template<typename _Tp>
 976     inline complex<_Tp>
 977     tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
 978 #endif
 979
 980
 981   // 26.2.8/9  pow(__x, __y): Returns the complex power base of __x
 982   //                          raised to the __y-th power.  The branch
 983   //                          cut is on the negative axis.
 984   template<typename _Tp>
 985     complex<_Tp>
 986     __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
 987     {
 988       complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
 989
 990       while (__n >>= 1)
 991         {
 992           __x *= __x;
 993           if (__n % 2)
 994             __y *= __x;
 995         }
 996
 997       return __y;
 998     }
 999
1000   // In C++11 mode we used to implement the resolution of
1001   // DR 844. complex pow return type is ambiguous.
1002   // thus the following overload was disabled in that mode.  However, doing
1003   // that causes all sorts of issues, see, for example:
1004   //   http://gcc.gnu.org/ml/libstdc++/2013-01/msg00058.html
1005   // and also PR57974.
1006   template<typename _Tp>
1007     inline complex<_Tp>
1008     pow(const complex<_Tp>& __z, int __n)
1009     {
1010       return __n < 0
1011         ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(unsigned)__n)
1012         : std::__complex_pow_unsigned(__z, __n);
1013     }
1014
1015   template<typename _Tp>
1016     complex<_Tp>
1017     pow(const complex<_Tp>& __x, const _Tp& __y)
1018     {
1019 #if ! _GLIBCXX_USE_C99_COMPLEX
1020       if (__x == _Tp())
1021         return _Tp();
1022 #endif
1023       if (__x.imag() == _Tp() && __x.real() > _Tp())
1024         return pow(__x.real(), __y);
1025
1026       complex<_Tp> __t = std::log(__x);
1027       return std::polar<_Tp>(exp(__y * __t.real()), __y * __t.imag());
1028     }
1029
1030   template<typename _Tp>
1031     inline complex<_Tp>
1032     __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1033     { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
1034
1035 #if _GLIBCXX_USE_C99_COMPLEX
1036   inline __complex__ float
1037   __complex_pow(__complex__ float __x, __complex__ float __y)
1038   { return __builtin_cpowf(__x, __y); }
1039
1040   inline __complex__ double
1041   __complex_pow(__complex__ double __x, __complex__ double __y)
1042   { return __builtin_cpow(__x, __y); }
1043
1044   inline __complex__ long double
1045   __complex_pow(const __complex__ long double& __x,
1046                 const __complex__ long double& __y)
1047   { return __builtin_cpowl(__x, __y); }
1048
1049   template<typename _Tp>
1050     inline complex<_Tp>
1051     pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1052     { return __complex_pow(__x.__rep(), __y.__rep()); }
1053 #else
1054   template<typename _Tp>
1055     inline complex<_Tp>
1056     pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1057     { return __complex_pow(__x, __y); }
1058 #endif
1059
1060   template<typename _Tp>
1061     inline complex<_Tp>
1062     pow(const _Tp& __x, const complex<_Tp>& __y)
1063     {
1064       return __x > _Tp() ? std::polar<_Tp>(pow(__x, __y.real()),
1065                                            __y.imag() * log(__x))
1066                          : std::pow(complex<_Tp>(__x), __y);
1067     }
1068
1069   /// 26.2.3  complex specializations
1070   /// complex<float> specialization
1071   template<>
1072     struct complex<float>
1073     {
1074       typedef float value_type;
1075       typedef __complex__ float _ComplexT;
1076
1077       _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1078
1079       _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f)
1080 #if __cplusplus >= 201103L
1081       : _M_value{ __r, __i } { }
1082 #else
1083       {
1084         __real__ _M_value = __r;
1085         __imag__ _M_value = __i;
1086       }
1087 #endif
1088
1089       explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
1090       explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1091
1092 #if __cplusplus >= 201103L
1093       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1094       // DR 387. std::complex over-encapsulated.
1095       __attribute ((__abi_tag__ ("cxx11")))
1096       constexpr float
1097       real() const { return __real__ _M_value; }
1098
1099       __attribute ((__abi_tag__ ("cxx11")))
1100       constexpr float
1101       imag() const { return __imag__ _M_value; }
1102 #else
1103       float&
1104       real() { return __real__ _M_value; }
1105
1106       const float&
1107       real() const { return __real__ _M_value; }
1108
1109       float&
1110       imag() { return __imag__ _M_value; }
1111
1112       const float&
1113       imag() const { return __imag__ _M_value; }
1114 #endif
1115
1116       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1117       // DR 387. std::complex over-encapsulated.
1118       void
1119       real(float __val) { __real__ _M_value = __val; }
1120
1121       void
1122       imag(float __val) { __imag__ _M_value = __val; }
1123
1124       complex&
1125       operator=(float __f)
1126       {
1127         _M_value = __f;
1128         return *this;
1129       }
1130
1131       complex&
1132       operator+=(float __f)
1133       {
1134         _M_value += __f;
1135         return *this;
1136       }
1137
1138       complex&
1139       operator-=(float __f)
1140       {
1141         _M_value -= __f;
1142         return *this;
1143       }
1144
1145       complex&
1146       operator*=(float __f)
1147       {
1148         _M_value *= __f;
1149         return *this;
1150       }
1151
1152       complex&
1153       operator/=(float __f)
1154       {
1155         _M_value /= __f;
1156         return *this;
1157       }
1158
1159       // Let the compiler synthesize the copy and assignment
1160       // operator.  It always does a pretty good job.
1161 #if __cplusplus >= 201103L
1162       _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1163 #endif
1164
1165       template<typename _Tp>
1166         complex&
1167         operator=(const complex<_Tp>&  __z)
1168         {
1169           __real__ _M_value = __z.real();
1170           __imag__ _M_value = __z.imag();
1171           return *this;
1172         }
1173
1174       template<typename _Tp>
1175         complex&
1176         operator+=(const complex<_Tp>& __z)
1177         {
1178           __real__ _M_value += __z.real();
1179           __imag__ _M_value += __z.imag();
1180           return *this;
1181         }
1182
1183       template<class _Tp>
1184         complex&
1185         operator-=(const complex<_Tp>& __z)
1186         {
1187           __real__ _M_value -= __z.real();
1188           __imag__ _M_value -= __z.imag();
1189           return *this;
1190         }
1191
1192       template<class _Tp>
1193         complex&
1194         operator*=(const complex<_Tp>& __z)
1195         {
1196           _ComplexT __t;
1197           __real__ __t = __z.real();
1198           __imag__ __t = __z.imag();
1199           _M_value *= __t;
1200           return *this;
1201         }
1202
1203       template<class _Tp>
1204         complex&
1205         operator/=(const complex<_Tp>& __z)
1206         {
1207           _ComplexT __t;
1208           __real__ __t = __z.real();
1209           __imag__ __t = __z.imag();
1210           _M_value /= __t;
1211           return *this;
1212         }
1213
1214       _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1215
1216     private:
1217       _ComplexT _M_value;
1218     };
1219
1220   /// 26.2.3  complex specializations
1221   /// complex<double> specialization
1222   template<>
1223     struct complex<double>
1224     {
1225       typedef double value_type;
1226       typedef __complex__ double _ComplexT;
1227
1228       _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1229
1230       _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
1231 #if __cplusplus >= 201103L
1232       : _M_value{ __r, __i } { }
1233 #else
1234       {
1235         __real__ _M_value = __r;
1236         __imag__ _M_value = __i;
1237       }
1238 #endif
1239
1240       _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1241       : _M_value(__z.__rep()) { }
1242
1243       explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1244
1245 #if __cplusplus >= 201103L
1246       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1247       // DR 387. std::complex over-encapsulated.
1248       __attribute ((__abi_tag__ ("cxx11")))
1249       constexpr double
1250       real() const { return __real__ _M_value; }
1251
1252       __attribute ((__abi_tag__ ("cxx11")))
1253       constexpr double
1254       imag() const { return __imag__ _M_value; }
1255 #else
1256       double&
1257       real() { return __real__ _M_value; }
1258
1259       const double&
1260       real() const { return __real__ _M_value; }
1261
1262       double&
1263       imag() { return __imag__ _M_value; }
1264
1265       const double&
1266       imag() const { return __imag__ _M_value; }
1267 #endif
1268
1269       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1270       // DR 387. std::complex over-encapsulated.
1271       void
1272       real(double __val) { __real__ _M_value = __val; }
1273
1274       void
1275       imag(double __val) { __imag__ _M_value = __val; }
1276
1277       complex&
1278       operator=(double __d)
1279       {
1280         _M_value = __d;
1281         return *this;
1282       }
1283
1284       complex&
1285       operator+=(double __d)
1286       {
1287         _M_value += __d;
1288         return *this;
1289       }
1290
1291       complex&
1292       operator-=(double __d)
1293       {
1294         _M_value -= __d;
1295         return *this;
1296       }
1297
1298       complex&
1299       operator*=(double __d)
1300       {
1301         _M_value *= __d;
1302         return *this;
1303       }
1304
1305       complex&
1306       operator/=(double __d)
1307       {
1308         _M_value /= __d;
1309         return *this;
1310       }
1311
1312       // The compiler will synthesize this, efficiently.
1313 #if __cplusplus >= 201103L
1314       _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1315 #endif
1316
1317       template<typename _Tp>
1318         complex&
1319         operator=(const complex<_Tp>& __z)
1320         {
1321           __real__ _M_value = __z.real();
1322           __imag__ _M_value = __z.imag();
1323           return *this;
1324         }
1325
1326       template<typename _Tp>
1327         complex&
1328         operator+=(const complex<_Tp>& __z)
1329         {
1330           __real__ _M_value += __z.real();
1331           __imag__ _M_value += __z.imag();
1332           return *this;
1333         }
1334
1335       template<typename _Tp>
1336         complex&
1337         operator-=(const complex<_Tp>& __z)
1338         {
1339           __real__ _M_value -= __z.real();
1340           __imag__ _M_value -= __z.imag();
1341           return *this;
1342         }
1343
1344       template<typename _Tp>
1345         complex&
1346         operator*=(const complex<_Tp>& __z)
1347         {
1348           _ComplexT __t;
1349           __real__ __t = __z.real();
1350           __imag__ __t = __z.imag();
1351           _M_value *= __t;
1352           return *this;
1353         }
1354
1355       template<typename _Tp>
1356         complex&
1357         operator/=(const complex<_Tp>& __z)
1358         {
1359           _ComplexT __t;
1360           __real__ __t = __z.real();
1361           __imag__ __t = __z.imag();
1362           _M_value /= __t;
1363           return *this;
1364         }
1365
1366       _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1367
1368     private:
1369       _ComplexT _M_value;
1370     };
1371
1372   /// 26.2.3  complex specializations
1373   /// complex<long double> specialization
1374   template<>
1375     struct complex<long double>
1376     {
1377       typedef long double value_type;
1378       typedef __complex__ long double _ComplexT;
1379
1380       _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1381
1382       _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L,
1383                                  long double __i = 0.0L)
1384 #if __cplusplus >= 201103L
1385       : _M_value{ __r, __i } { }
1386 #else
1387       {
1388         __real__ _M_value = __r;
1389         __imag__ _M_value = __i;
1390       }
1391 #endif
1392
1393       _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1394       : _M_value(__z.__rep()) { }
1395
1396       _GLIBCXX_CONSTEXPR complex(const complex<double>& __z)
1397       : _M_value(__z.__rep()) { }
1398
1399 #if __cplusplus >= 201103L
1400       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1401       // DR 387. std::complex over-encapsulated.
1402       __attribute ((__abi_tag__ ("cxx11")))
1403       constexpr long double
1404       real() const { return __real__ _M_value; }
1405
1406       __attribute ((__abi_tag__ ("cxx11")))
1407       constexpr long double
1408       imag() const { return __imag__ _M_value; }
1409 #else
1410       long double&
1411       real() { return __real__ _M_value; }
1412
1413       const long double&
1414       real() const { return __real__ _M_value; }
1415
1416       long double&
1417       imag() { return __imag__ _M_value; }
1418
1419       const long double&
1420       imag() const { return __imag__ _M_value; }
1421 #endif
1422
1423       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1424       // DR 387. std::complex over-encapsulated.
1425       void
1426       real(long double __val) { __real__ _M_value = __val; }
1427
1428       void
1429       imag(long double __val) { __imag__ _M_value = __val; }
1430
1431       complex&
1432       operator=(long double __r)
1433       {
1434         _M_value = __r;
1435         return *this;
1436       }
1437
1438       complex&
1439       operator+=(long double __r)
1440       {
1441         _M_value += __r;
1442         return *this;
1443       }
1444
1445       complex&
1446       operator-=(long double __r)
1447       {
1448         _M_value -= __r;
1449         return *this;
1450       }
1451
1452       complex&
1453       operator*=(long double __r)
1454       {
1455         _M_value *= __r;
1456         return *this;
1457       }
1458
1459       complex&
1460       operator/=(long double __r)
1461       {
1462         _M_value /= __r;
1463         return *this;
1464       }
1465
1466       // The compiler knows how to do this efficiently
1467 #if __cplusplus >= 201103L
1468       _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1469 #endif
1470
1471       template<typename _Tp>
1472         complex&
1473         operator=(const complex<_Tp>& __z)
1474         {
1475           __real__ _M_value = __z.real();
1476           __imag__ _M_value = __z.imag();
1477           return *this;
1478         }
1479
1480       template<typename _Tp>
1481         complex&
1482         operator+=(const complex<_Tp>& __z)
1483         {
1484           __real__ _M_value += __z.real();
1485           __imag__ _M_value += __z.imag();
1486           return *this;
1487         }
1488
1489       template<typename _Tp>
1490         complex&
1491         operator-=(const complex<_Tp>& __z)
1492         {
1493           __real__ _M_value -= __z.real();
1494           __imag__ _M_value -= __z.imag();
1495           return *this;
1496         }
1497
1498       template<typename _Tp>
1499         complex&
1500         operator*=(const complex<_Tp>& __z)
1501         {
1502           _ComplexT __t;
1503           __real__ __t = __z.real();
1504           __imag__ __t = __z.imag();
1505           _M_value *= __t;
1506           return *this;
1507         }
1508
1509       template<typename _Tp>
1510         complex&
1511         operator/=(const complex<_Tp>& __z)
1512         {
1513           _ComplexT __t;
1514           __real__ __t = __z.real();
1515           __imag__ __t = __z.imag();
1516           _M_value /= __t;
1517           return *this;
1518         }
1519
1520       _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1521
1522     private:
1523       _ComplexT _M_value;
1524     };
1525
1526   // These bits have to be at the end of this file, so that the
1527   // specializations have all been defined.
1528   inline _GLIBCXX_CONSTEXPR
1529   complex<float>::complex(const complex<double>& __z)
1530   : _M_value(__z.__rep()) { }
1531
1532   inline _GLIBCXX_CONSTEXPR
1533   complex<float>::complex(const complex<long double>& __z)
1534   : _M_value(__z.__rep()) { }
1535
1536   inline _GLIBCXX_CONSTEXPR
1537   complex<double>::complex(const complex<long double>& __z)
1538   : _M_value(__z.__rep()) { }
1539
1540   // Inhibit implicit instantiations for required instantiations,
1541   // which are defined via explicit instantiations elsewhere.
1542   // NB:  This syntax is a GNU extension.
1543 #if _GLIBCXX_EXTERN_TEMPLATE
1544   extern template istream& operator>>(istream&, complex<float>&);
1545   extern template ostream& operator<<(ostream&, const complex<float>&);
1546   extern template istream& operator>>(istream&, complex<double>&);
1547   extern template ostream& operator<<(ostream&, const complex<double>&);
1548   extern template istream& operator>>(istream&, complex<long double>&);
1549   extern template ostream& operator<<(ostream&, const complex<long double>&);
1550
1551 #ifdef _GLIBCXX_USE_WCHAR_T
1552   extern template wistream& operator>>(wistream&, complex<float>&);
1553   extern template wostream& operator<<(wostream&, const complex<float>&);
1554   extern template wistream& operator>>(wistream&, complex<double>&);
1555   extern template wostream& operator<<(wostream&, const complex<double>&);
1556   extern template wistream& operator>>(wistream&, complex<long double>&);
1557   extern template wostream& operator<<(wostream&, const complex<long double>&);
1558 #endif
1559 #endif
1560
1561   // @} group complex_numbers
1562
1563 _GLIBCXX_END_NAMESPACE_VERSION
1564 } // namespace
1565
1566 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
1567 {
1568 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1569
1570   // See ext/type_traits.h for the primary template.
1571   template<typename _Tp, typename _Up>
1572     struct __promote_2<std::complex<_Tp>, _Up>
1573     {
1574     public:
1575       typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1576     };
1577
1578   template<typename _Tp, typename _Up>
1579     struct __promote_2<_Tp, std::complex<_Up> >
1580     {
1581     public:
1582       typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1583     };
1584
1585   template<typename _Tp, typename _Up>
1586     struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
1587     {
1588     public:
1589       typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1590     };
1591
1592 _GLIBCXX_END_NAMESPACE_VERSION
1593 } // namespace
1594
1595 #if __cplusplus >= 201103L
1596
1597 namespace std _GLIBCXX_VISIBILITY(default)
1598 {
1599 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1600
1601   // Forward declarations.
1602   template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
1603   template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
1604   template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
1605
1606   template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
1607   template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
1608   template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
1609   // DR 595.
1610   template<typename _Tp> _Tp               fabs(const std::complex<_Tp>&);
1611
1612   template<typename _Tp>
1613     inline std::complex<_Tp>
1614     __complex_acos(const std::complex<_Tp>& __z)
1615     {
1616       const std::complex<_Tp> __t = std::asin(__z);
1617       const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
1618       return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
1619     }
1620
1621 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1622   inline __complex__ float
1623   __complex_acos(__complex__ float __z)
1624   { return __builtin_cacosf(__z); }
1625
1626   inline __complex__ double
1627   __complex_acos(__complex__ double __z)
1628   { return __builtin_cacos(__z); }
1629
1630   inline __complex__ long double
1631   __complex_acos(const __complex__ long double& __z)
1632   { return __builtin_cacosl(__z); }
1633
1634   template<typename _Tp>
1635     inline std::complex<_Tp>
1636     acos(const std::complex<_Tp>& __z)
1637     { return __complex_acos(__z.__rep()); }
1638 #else
1639   /// acos(__z) [8.1.2].
1640   //  Effects:  Behaves the same as C99 function cacos, defined
1641   //            in subclause 7.3.5.1.
1642   template<typename _Tp>
1643     inline std::complex<_Tp>
1644     acos(const std::complex<_Tp>& __z)
1645     { return __complex_acos(__z); }
1646 #endif
1647
1648   template<typename _Tp>
1649     inline std::complex<_Tp>
1650     __complex_asin(const std::complex<_Tp>& __z)
1651     {
1652       std::complex<_Tp> __t(-__z.imag(), __z.real());
1653       __t = std::asinh(__t);
1654       return std::complex<_Tp>(__t.imag(), -__t.real());
1655     }
1656
1657 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1658   inline __complex__ float
1659   __complex_asin(__complex__ float __z)
1660   { return __builtin_casinf(__z); }
1661
1662   inline __complex__ double
1663   __complex_asin(__complex__ double __z)
1664   { return __builtin_casin(__z); }
1665
1666   inline __complex__ long double
1667   __complex_asin(const __complex__ long double& __z)
1668   { return __builtin_casinl(__z); }
1669
1670   template<typename _Tp>
1671     inline std::complex<_Tp>
1672     asin(const std::complex<_Tp>& __z)
1673     { return __complex_asin(__z.__rep()); }
1674 #else
1675   /// asin(__z) [8.1.3].
1676   //  Effects:  Behaves the same as C99 function casin, defined
1677   //            in subclause 7.3.5.2.
1678   template<typename _Tp>
1679     inline std::complex<_Tp>
1680     asin(const std::complex<_Tp>& __z)
1681     { return __complex_asin(__z); }
1682 #endif
1683
1684   template<typename _Tp>
1685     std::complex<_Tp>
1686     __complex_atan(const std::complex<_Tp>& __z)
1687     {
1688       const _Tp __r2 = __z.real() * __z.real();
1689       const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
1690
1691       _Tp __num = __z.imag() + _Tp(1.0);
1692       _Tp __den = __z.imag() - _Tp(1.0);
1693
1694       __num = __r2 + __num * __num;
1695       __den = __r2 + __den * __den;
1696
1697       return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
1698                                _Tp(0.25) * log(__num / __den));
1699     }
1700
1701 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1702   inline __complex__ float
1703   __complex_atan(__complex__ float __z)
1704   { return __builtin_catanf(__z); }
1705
1706   inline __complex__ double
1707   __complex_atan(__complex__ double __z)
1708   { return __builtin_catan(__z); }
1709
1710   inline __complex__ long double
1711   __complex_atan(const __complex__ long double& __z)
1712   { return __builtin_catanl(__z); }
1713
1714   template<typename _Tp>
1715     inline std::complex<_Tp>
1716     atan(const std::complex<_Tp>& __z)
1717     { return __complex_atan(__z.__rep()); }
1718 #else
1719   /// atan(__z) [8.1.4].
1720   //  Effects:  Behaves the same as C99 function catan, defined
1721   //            in subclause 7.3.5.3.
1722   template<typename _Tp>
1723     inline std::complex<_Tp>
1724     atan(const std::complex<_Tp>& __z)
1725     { return __complex_atan(__z); }
1726 #endif
1727
1728   template<typename _Tp>
1729     std::complex<_Tp>
1730     __complex_acosh(const std::complex<_Tp>& __z)
1731     {
1732       // Kahan's formula.
1733       return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
1734                                  + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
1735     }
1736
1737 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1738   inline __complex__ float
1739   __complex_acosh(__complex__ float __z)
1740   { return __builtin_cacoshf(__z); }
1741
1742   inline __complex__ double
1743   __complex_acosh(__complex__ double __z)
1744   { return __builtin_cacosh(__z); }
1745
1746   inline __complex__ long double
1747   __complex_acosh(const __complex__ long double& __z)
1748   { return __builtin_cacoshl(__z); }
1749
1750   template<typename _Tp>
1751     inline std::complex<_Tp>
1752     acosh(const std::complex<_Tp>& __z)
1753     { return __complex_acosh(__z.__rep()); }
1754 #else
1755   /// acosh(__z) [8.1.5].
1756   //  Effects:  Behaves the same as C99 function cacosh, defined
1757   //            in subclause 7.3.6.1.
1758   template<typename _Tp>
1759     inline std::complex<_Tp>
1760     acosh(const std::complex<_Tp>& __z)
1761     { return __complex_acosh(__z); }
1762 #endif
1763
1764   template<typename _Tp>
1765     std::complex<_Tp>
1766     __complex_asinh(const std::complex<_Tp>& __z)
1767     {
1768       std::complex<_Tp> __t((__z.real() - __z.imag())
1769                             * (__z.real() + __z.imag()) + _Tp(1.0),
1770                             _Tp(2.0) * __z.real() * __z.imag());
1771       __t = std::sqrt(__t);
1772
1773       return std::log(__t + __z);
1774     }
1775
1776 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1777   inline __complex__ float
1778   __complex_asinh(__complex__ float __z)
1779   { return __builtin_casinhf(__z); }
1780
1781   inline __complex__ double
1782   __complex_asinh(__complex__ double __z)
1783   { return __builtin_casinh(__z); }
1784
1785   inline __complex__ long double
1786   __complex_asinh(const __complex__ long double& __z)
1787   { return __builtin_casinhl(__z); }
1788
1789   template<typename _Tp>
1790     inline std::complex<_Tp>
1791     asinh(const std::complex<_Tp>& __z)
1792     { return __complex_asinh(__z.__rep()); }
1793 #else
1794   /// asinh(__z) [8.1.6].
1795   //  Effects:  Behaves the same as C99 function casin, defined
1796   //            in subclause 7.3.6.2.
1797   template<typename _Tp>
1798     inline std::complex<_Tp>
1799     asinh(const std::complex<_Tp>& __z)
1800     { return __complex_asinh(__z); }
1801 #endif
1802
1803   template<typename _Tp>
1804     std::complex<_Tp>
1805     __complex_atanh(const std::complex<_Tp>& __z)
1806     {
1807       const _Tp __i2 = __z.imag() * __z.imag();
1808       const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
1809
1810       _Tp __num = _Tp(1.0) + __z.real();
1811       _Tp __den = _Tp(1.0) - __z.real();
1812
1813       __num = __i2 + __num * __num;
1814       __den = __i2 + __den * __den;
1815
1816       return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
1817                                _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
1818     }
1819
1820 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1821   inline __complex__ float
1822   __complex_atanh(__complex__ float __z)
1823   { return __builtin_catanhf(__z); }
1824
1825   inline __complex__ double
1826   __complex_atanh(__complex__ double __z)
1827   { return __builtin_catanh(__z); }
1828
1829   inline __complex__ long double
1830   __complex_atanh(const __complex__ long double& __z)
1831   { return __builtin_catanhl(__z); }
1832
1833   template<typename _Tp>
1834     inline std::complex<_Tp>
1835     atanh(const std::complex<_Tp>& __z)
1836     { return __complex_atanh(__z.__rep()); }
1837 #else
1838   /// atanh(__z) [8.1.7].
1839   //  Effects:  Behaves the same as C99 function catanh, defined
1840   //            in subclause 7.3.6.3.
1841   template<typename _Tp>
1842     inline std::complex<_Tp>
1843     atanh(const std::complex<_Tp>& __z)
1844     { return __complex_atanh(__z); }
1845 #endif
1846
1847   template<typename _Tp>
1848     inline _Tp
1849     /// fabs(__z) [8.1.8].
1850     //  Effects:  Behaves the same as C99 function cabs, defined
1851     //            in subclause 7.3.8.1.
1852     fabs(const std::complex<_Tp>& __z)
1853     { return std::abs(__z); }
1854
1855   /// Additional overloads [8.1.9].
1856   template<typename _Tp>
1857     inline typename __gnu_cxx::__promote<_Tp>::__type
1858     arg(_Tp __x)
1859     {
1860       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1861 #if (_GLIBCXX11_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
1862       return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
1863                                : __type();
1864 #else
1865       return std::arg(std::complex<__type>(__x));
1866 #endif
1867     }
1868
1869   template<typename _Tp>
1870     _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
1871     imag(_Tp)
1872     { return _Tp(); }
1873
1874   template<typename _Tp>
1875     inline typename __gnu_cxx::__promote<_Tp>::__type
1876     norm(_Tp __x)
1877     {
1878       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1879       return __type(__x) * __type(__x);
1880     }
1881
1882   template<typename _Tp>
1883     _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
1884     real(_Tp __x)
1885     { return __x; }
1886
1887   template<typename _Tp, typename _Up>
1888     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1889     pow(const std::complex<_Tp>& __x, const _Up& __y)
1890     {
1891       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1892       return std::pow(std::complex<__type>(__x), __type(__y));
1893     }
1894
1895   template<typename _Tp, typename _Up>
1896     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1897     pow(const _Tp& __x, const std::complex<_Up>& __y)
1898     {
1899       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1900       return std::pow(__type(__x), std::complex<__type>(__y));
1901     }
1902
1903   template<typename _Tp, typename _Up>
1904     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1905     pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
1906     {
1907       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1908       return std::pow(std::complex<__type>(__x),
1909                       std::complex<__type>(__y));
1910     }
1911
1912   // Forward declarations.
1913   // DR 781.
1914   template<typename _Tp> std::complex<_Tp> proj(const std::complex<_Tp>&);
1915
1916   template<typename _Tp>
1917     std::complex<_Tp>
1918     __complex_proj(const std::complex<_Tp>& __z)
1919     {
1920       const _Tp __den = (__z.real() * __z.real()
1921                          + __z.imag() * __z.imag() + _Tp(1.0));
1922
1923       return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den,
1924                                (_Tp(2.0) * __z.imag()) / __den);
1925     }
1926
1927 #if _GLIBCXX_USE_C99_COMPLEX
1928   inline __complex__ float
1929   __complex_proj(__complex__ float __z)
1930   { return __builtin_cprojf(__z); }
1931
1932   inline __complex__ double
1933   __complex_proj(__complex__ double __z)
1934   { return __builtin_cproj(__z); }
1935
1936   inline __complex__ long double
1937   __complex_proj(const __complex__ long double& __z)
1938   { return __builtin_cprojl(__z); }
1939
1940   template<typename _Tp>
1941     inline std::complex<_Tp>
1942     proj(const std::complex<_Tp>& __z)
1943     { return __complex_proj(__z.__rep()); }
1944 #else
1945   template<typename _Tp>
1946     inline std::complex<_Tp>
1947     proj(const std::complex<_Tp>& __z)
1948     { return __complex_proj(__z); }
1949 #endif
1950
1951   template<typename _Tp>
1952     inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
1953     proj(_Tp __x)
1954     {
1955       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1956       return std::proj(std::complex<__type>(__x));
1957     }
1958
1959   template<typename _Tp>
1960     inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
1961     conj(_Tp __x)
1962     {
1963       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1964       return std::complex<__type>(__x, -__type());
1965     }
1966
1967 #if __cplusplus > 201103L
1968
1969 inline namespace literals {
1970 inline namespace complex_literals {
1971 #pragma GCC diagnostic push
1972 #pragma GCC diagnostic ignored "-Wliteral-suffix"
1973 #define __cpp_lib_complex_udls 201309
1974
1975   constexpr std::complex<float>
1976   operator""if(long double __num)
1977   { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
1978
1979   constexpr std::complex<float>
1980   operator""if(unsigned long long __num)
1981   { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
1982
1983   constexpr std::complex<double>
1984   operator""i(long double __num)
1985   { return std::complex<double>{0.0, static_cast<double>(__num)}; }
1986
1987   constexpr std::complex<double>
1988   operator""i(unsigned long long __num)
1989   { return std::complex<double>{0.0, static_cast<double>(__num)}; }
1990
1991   constexpr std::complex<long double>
1992   operator""il(long double __num)
1993   { return std::complex<long double>{0.0L, __num}; }
1994
1995   constexpr std::complex<long double>
1996   operator""il(unsigned long long __num)
1997   { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }
1998
1999 #pragma GCC diagnostic pop
2000 } // inline namespace complex_literals
2001 } // inline namespace literals
2002
2003 #endif // C++14
2004
2005 _GLIBCXX_END_NAMESPACE_VERSION
2006 } // namespace
2007
2008 #endif  // C++11
2009
2010 #endif  /* _GLIBCXX_COMPLEX */