libstdc++-v3/include/std/complex

   1 // The template and inlines for the -*- C++ -*- complex number classes.
   2
   3 // Copyright (C) 1997-2024 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 #ifdef __clang__
  51 #pragma clang diagnostic push
  52 #pragma clang diagnostic ignored "-Wc99-extensions"
  53 #endif
  54
  55 #define __glibcxx_want_constexpr_complex
  56 #define __glibcxx_want_complex_udls
  57 #include <bits/version.h>
  58
  59 namespace std _GLIBCXX_VISIBILITY(default)
  60 {
  61 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  62
  63   /**
  64    * @defgroup complex_numbers Complex Numbers
  65    * @ingroup numerics
  66    *
  67    * Classes and functions for complex numbers.
  68    * @{
  69    */
  70
  71   // Forward declarations.
  72   template<typename _Tp> class complex;
  73   template<> class complex<float>;
  74   template<> class complex<double>;
  75   template<> class complex<long double>;
  76
  77   ///  Return magnitude of @a z.
  78   template<typename _Tp> _Tp abs(const complex<_Tp>&);
  79   ///  Return phase angle of @a z.
  80   template<typename _Tp> _Tp arg(const complex<_Tp>&);
  81   ///  Return @a z magnitude squared.
  82   template<typename _Tp> _Tp _GLIBCXX20_CONSTEXPR norm(const complex<_Tp>&);
  83
  84   ///  Return complex conjugate of @a z.
  85   template<typename _Tp>
  86     _GLIBCXX20_CONSTEXPR complex<_Tp> conj(const complex<_Tp>&);
  87   ///  Return complex with magnitude @a rho and angle @a theta.
  88   template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
  89
  90   // Transcendentals:
  91   /// Return complex cosine of @a z.
  92   template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
  93   /// Return complex hyperbolic cosine of @a z.
  94   template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
  95   /// Return complex base e exponential of @a z.
  96   template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
  97   /// Return complex natural logarithm of @a z.
  98   template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
  99   /// Return complex base 10 logarithm of @a z.
 100   template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
 101   /// Return @a x to the @a y'th power.
 102   template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
 103   /// Return @a x to the @a y'th power.
 104   template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
 105   /// Return @a x to the @a y'th power.
 106   template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
 107                                           const complex<_Tp>&);
 108   /// Return @a x to the @a y'th power.
 109   template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
 110   /// Return complex sine of @a z.
 111   template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
 112   /// Return complex hyperbolic sine of @a z.
 113   template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
 114   /// Return complex square root of @a z.
 115   template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
 116   /// Return complex tangent of @a z.
 117   template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
 118   /// Return complex hyperbolic tangent of @a z.
 119   template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
 120
 121
 122   // 26.2.2  Primary template class complex
 123   /**
 124    *  Template to represent complex numbers.
 125    *
 126    *  Specializations for float, double, and long double are part of the
 127    *  library.  Results with any other type are not guaranteed.
 128    *
 129    *  @param  Tp  Type of real and imaginary values.
 130   */
 131   template<typename _Tp>
 132     class complex
 133     {
 134     public:
 135       /// Value typedef.
 136       typedef _Tp value_type;
 137
 138       ///  Default constructor.  First parameter is x, second parameter is y.
 139       ///  Unspecified parameters default to 0.
 140       _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
 141       : _M_real(__r), _M_imag(__i) { }
 142
 143       // Let the compiler synthesize the copy constructor
 144 #if __cplusplus >= 201103L
 145       constexpr complex(const complex&) = default;
 146 #endif
 147
 148       ///  Converting constructor.
 149       template<typename _Up>
 150 #if __cplusplus > 202002L
 151         explicit(!requires(_Up __u) { _Tp{__u}; })
 152 #endif
 153         _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z)
 154         : _M_real(_Tp(__z.real())), _M_imag(_Tp(__z.imag())) { }
 155
 156 #if __cplusplus >= 201103L
 157       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 158       // DR 387. std::complex over-encapsulated.
 159       _GLIBCXX_ABI_TAG_CXX11
 160       constexpr _Tp
 161       real() const { return _M_real; }
 162
 163       _GLIBCXX_ABI_TAG_CXX11
 164       constexpr _Tp
 165       imag() const { return _M_imag; }
 166 #else
 167       ///  Return real part of complex number.
 168       _Tp&
 169       real() { return _M_real; }
 170
 171       ///  Return real part of complex number.
 172       const _Tp&
 173       real() const { return _M_real; }
 174
 175       ///  Return imaginary part of complex number.
 176       _Tp&
 177       imag() { return _M_imag; }
 178
 179       ///  Return imaginary part of complex number.
 180       const _Tp&
 181       imag() const { return _M_imag; }
 182 #endif
 183
 184       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 185       // DR 387. std::complex over-encapsulated.
 186       _GLIBCXX20_CONSTEXPR void
 187       real(_Tp __val) { _M_real = __val; }
 188
 189       _GLIBCXX20_CONSTEXPR void
 190       imag(_Tp __val) { _M_imag = __val; }
 191
 192       /// Assign a scalar to this complex number.
 193       _GLIBCXX20_CONSTEXPR complex<_Tp>& operator=(const _Tp&);
 194
 195       /// Add a scalar to this complex number.
 196       // 26.2.5/1
 197       _GLIBCXX20_CONSTEXPR complex<_Tp>&
 198       operator+=(const _Tp& __t)
 199       {
 200         _M_real += __t;
 201         return *this;
 202       }
 203
 204       /// Subtract a scalar from this complex number.
 205       // 26.2.5/3
 206       _GLIBCXX20_CONSTEXPR complex<_Tp>&
 207       operator-=(const _Tp& __t)
 208       {
 209         _M_real -= __t;
 210         return *this;
 211       }
 212
 213       /// Multiply this complex number by a scalar.
 214       _GLIBCXX20_CONSTEXPR complex<_Tp>& operator*=(const _Tp&);
 215       /// Divide this complex number by a scalar.
 216       _GLIBCXX20_CONSTEXPR complex<_Tp>& operator/=(const _Tp&);
 217
 218       // Let the compiler synthesize the copy assignment operator
 219 #if __cplusplus >= 201103L
 220       _GLIBCXX20_CONSTEXPR complex& operator=(const complex&) = default;
 221 #endif
 222
 223       /// Assign another complex number to this one.
 224       template<typename _Up>
 225         _GLIBCXX20_CONSTEXPR complex<_Tp>& operator=(const complex<_Up>&);
 226       /// Add another complex number to this one.
 227       template<typename _Up>
 228         _GLIBCXX20_CONSTEXPR complex<_Tp>& operator+=(const complex<_Up>&);
 229       /// Subtract another complex number from this one.
 230       template<typename _Up>
 231         _GLIBCXX20_CONSTEXPR complex<_Tp>& operator-=(const complex<_Up>&);
 232       /// Multiply this complex number by another.
 233       template<typename _Up>
 234         _GLIBCXX20_CONSTEXPR complex<_Tp>& operator*=(const complex<_Up>&);
 235       /// Divide this complex number by another.
 236       template<typename _Up>
 237         _GLIBCXX20_CONSTEXPR complex<_Tp>& operator/=(const complex<_Up>&);
 238
 239       _GLIBCXX_CONSTEXPR complex __rep() const
 240       { return *this; }
 241
 242     private:
 243       _Tp _M_real;
 244       _Tp _M_imag;
 245     };
 246
 247   template<typename _Tp>
 248     _GLIBCXX20_CONSTEXPR complex<_Tp>&
 249     complex<_Tp>::operator=(const _Tp& __t)
 250     {
 251      _M_real = __t;
 252      _M_imag = _Tp();
 253      return *this;
 254     }
 255
 256   // 26.2.5/5
 257   template<typename _Tp>
 258     _GLIBCXX20_CONSTEXPR complex<_Tp>&
 259     complex<_Tp>::operator*=(const _Tp& __t)
 260     {
 261       _M_real *= __t;
 262       _M_imag *= __t;
 263       return *this;
 264     }
 265
 266   // 26.2.5/7
 267   template<typename _Tp>
 268     _GLIBCXX20_CONSTEXPR complex<_Tp>&
 269     complex<_Tp>::operator/=(const _Tp& __t)
 270     {
 271       _M_real /= __t;
 272       _M_imag /= __t;
 273       return *this;
 274     }
 275
 276   template<typename _Tp>
 277     template<typename _Up>
 278     _GLIBCXX20_CONSTEXPR complex<_Tp>&
 279     complex<_Tp>::operator=(const complex<_Up>& __z)
 280     {
 281       _M_real = __z.real();
 282       _M_imag = __z.imag();
 283       return *this;
 284     }
 285
 286   // 26.2.5/9
 287   template<typename _Tp>
 288     template<typename _Up>
 289     _GLIBCXX20_CONSTEXPR complex<_Tp>&
 290     complex<_Tp>::operator+=(const complex<_Up>& __z)
 291     {
 292       _M_real += __z.real();
 293       _M_imag += __z.imag();
 294       return *this;
 295     }
 296
 297   // 26.2.5/11
 298   template<typename _Tp>
 299     template<typename _Up>
 300     _GLIBCXX20_CONSTEXPR complex<_Tp>&
 301     complex<_Tp>::operator-=(const complex<_Up>& __z)
 302     {
 303       _M_real -= __z.real();
 304       _M_imag -= __z.imag();
 305       return *this;
 306     }
 307
 308   // 26.2.5/13
 309   // XXX: This is a grammar school implementation.
 310   template<typename _Tp>
 311     template<typename _Up>
 312     _GLIBCXX20_CONSTEXPR complex<_Tp>&
 313     complex<_Tp>::operator*=(const complex<_Up>& __z)
 314     {
 315       const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
 316       _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
 317       _M_real = __r;
 318       return *this;
 319     }
 320
 321   // 26.2.5/15
 322   // XXX: This is a grammar school implementation.
 323   template<typename _Tp>
 324     template<typename _Up>
 325     _GLIBCXX20_CONSTEXPR complex<_Tp>&
 326     complex<_Tp>::operator/=(const complex<_Up>& __z)
 327     {
 328       const _Tp __r =  _M_real * __z.real() + _M_imag * __z.imag();
 329       const _Tp __n = std::norm(__z);
 330       _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
 331       _M_real = __r / __n;
 332       return *this;
 333     }
 334
 335   // Operators:
 336   ///@{
 337   ///  Return new complex value @a x plus @a y.
 338   template<typename _Tp>
 339     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 340     operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
 341     {
 342       complex<_Tp> __r = __x;
 343       __r += __y;
 344       return __r;
 345     }
 346
 347   template<typename _Tp>
 348     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 349     operator+(const complex<_Tp>& __x, const _Tp& __y)
 350     {
 351       complex<_Tp> __r = __x;
 352       __r += __y;
 353       return __r;
 354     }
 355
 356   template<typename _Tp>
 357     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 358     operator+(const _Tp& __x, const complex<_Tp>& __y)
 359     {
 360       complex<_Tp> __r = __y;
 361       __r += __x;
 362       return __r;
 363     }
 364   ///@}
 365
 366   ///@{
 367   ///  Return new complex value @a x minus @a y.
 368   template<typename _Tp>
 369     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 370     operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
 371     {
 372       complex<_Tp> __r = __x;
 373       __r -= __y;
 374       return __r;
 375     }
 376
 377   template<typename _Tp>
 378     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 379     operator-(const complex<_Tp>& __x, const _Tp& __y)
 380     {
 381       complex<_Tp> __r = __x;
 382       __r -= __y;
 383       return __r;
 384     }
 385
 386   template<typename _Tp>
 387     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 388     operator-(const _Tp& __x, const complex<_Tp>& __y)
 389     {
 390       complex<_Tp> __r = -__y;
 391       __r += __x;
 392       return __r;
 393     }
 394   ///@}
 395
 396   ///@{
 397   ///  Return new complex value @a x times @a y.
 398   template<typename _Tp>
 399     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 400     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
 401     {
 402       complex<_Tp> __r = __x;
 403       __r *= __y;
 404       return __r;
 405     }
 406
 407   template<typename _Tp>
 408     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 409     operator*(const complex<_Tp>& __x, const _Tp& __y)
 410     {
 411       complex<_Tp> __r = __x;
 412       __r *= __y;
 413       return __r;
 414     }
 415
 416   template<typename _Tp>
 417     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 418     operator*(const _Tp& __x, const complex<_Tp>& __y)
 419     {
 420       complex<_Tp> __r = __y;
 421       __r *= __x;
 422       return __r;
 423     }
 424   ///@}
 425
 426   ///@{
 427   ///  Return new complex value @a x divided by @a y.
 428   template<typename _Tp>
 429     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 430     operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
 431     {
 432       complex<_Tp> __r = __x;
 433       __r /= __y;
 434       return __r;
 435     }
 436
 437   template<typename _Tp>
 438     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 439     operator/(const complex<_Tp>& __x, const _Tp& __y)
 440     {
 441       complex<_Tp> __r = __x;
 442       __r /= __y;
 443       return __r;
 444     }
 445
 446   template<typename _Tp>
 447     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 448     operator/(const _Tp& __x, const complex<_Tp>& __y)
 449     {
 450       complex<_Tp> __r = __x;
 451       __r /= __y;
 452       return __r;
 453     }
 454   ///@}
 455
 456   ///  Return @a x.
 457   template<typename _Tp>
 458     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 459     operator+(const complex<_Tp>& __x)
 460     { return __x; }
 461
 462   ///  Return complex negation of @a x.
 463   template<typename _Tp>
 464     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 465     operator-(const complex<_Tp>& __x)
 466     { return complex<_Tp>(-__x.real(), -__x.imag()); }
 467
 468   ///@{
 469   ///  Return true if @a x is equal to @a y.
 470   template<typename _Tp>
 471     inline _GLIBCXX_CONSTEXPR bool
 472     operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
 473     { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
 474
 475   template<typename _Tp>
 476     inline _GLIBCXX_CONSTEXPR bool
 477     operator==(const complex<_Tp>& __x, const _Tp& __y)
 478     { return __x.real() == __y && __x.imag() == _Tp(); }
 479
 480 #if !(__cpp_impl_three_way_comparison >= 201907L)
 481   template<typename _Tp>
 482     inline _GLIBCXX_CONSTEXPR bool
 483     operator==(const _Tp& __x, const complex<_Tp>& __y)
 484     { return __x == __y.real() && _Tp() == __y.imag(); }
 485   ///@}
 486
 487   ///@{
 488   ///  Return false if @a x is equal to @a y.
 489   template<typename _Tp>
 490     inline _GLIBCXX_CONSTEXPR bool
 491     operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
 492     { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
 493
 494   template<typename _Tp>
 495     inline _GLIBCXX_CONSTEXPR bool
 496     operator!=(const complex<_Tp>& __x, const _Tp& __y)
 497     { return __x.real() != __y || __x.imag() != _Tp(); }
 498
 499   template<typename _Tp>
 500     inline _GLIBCXX_CONSTEXPR bool
 501     operator!=(const _Tp& __x, const complex<_Tp>& __y)
 502     { return __x != __y.real() || _Tp() != __y.imag(); }
 503 #endif
 504   ///@}
 505
 506   ///  Extraction operator for complex values.
 507   template<typename _Tp, typename _CharT, class _Traits>
 508     basic_istream<_CharT, _Traits>&
 509     operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
 510     {
 511       bool __fail = true;
 512       _CharT __ch;
 513       if (__is >> __ch)
 514         {
 515           if (_Traits::eq(__ch, __is.widen('(')))
 516             {
 517               _Tp __u;
 518               if (__is >> __u >> __ch)
 519                 {
 520                   const _CharT __rparen = __is.widen(')');
 521                   if (_Traits::eq(__ch, __rparen))
 522                     {
 523                       __x = __u;
 524                       __fail = false;
 525                     }
 526                   else if (_Traits::eq(__ch, __is.widen(',')))
 527                     {
 528                       _Tp __v;
 529                       if (__is >> __v >> __ch)
 530                         {
 531                           if (_Traits::eq(__ch, __rparen))
 532                             {
 533                               __x = complex<_Tp>(__u, __v);
 534                               __fail = false;
 535                             }
 536                           else
 537                             __is.putback(__ch);
 538                         }
 539                     }
 540                   else
 541                     __is.putback(__ch);
 542                 }
 543             }
 544           else
 545             {
 546               __is.putback(__ch);
 547               _Tp __u;
 548               if (__is >> __u)
 549                 {
 550                   __x = __u;
 551                   __fail = false;
 552                 }
 553             }
 554         }
 555       if (__fail)
 556         __is.setstate(ios_base::failbit);
 557       return __is;
 558     }
 559
 560   ///  Insertion operator for complex values.
 561   template<typename _Tp, typename _CharT, class _Traits>
 562     basic_ostream<_CharT, _Traits>&
 563     operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
 564     {
 565       basic_ostringstream<_CharT, _Traits> __s;
 566       __s.flags(__os.flags());
 567       __s.imbue(__os.getloc());
 568       __s.precision(__os.precision());
 569       __s << '(' << __x.real() << ',' << __x.imag() << ')';
 570       return __os << __s.str();
 571     }
 572
 573   // Values
 574 #if __cplusplus >= 201103L
 575   template<typename _Tp>
 576     constexpr _Tp
 577     real(const complex<_Tp>& __z)
 578     { return __z.real(); }
 579
 580   template<typename _Tp>
 581     constexpr _Tp
 582     imag(const complex<_Tp>& __z)
 583     { return __z.imag(); }
 584 #else
 585   template<typename _Tp>
 586     inline _Tp&
 587     real(complex<_Tp>& __z)
 588     { return __z.real(); }
 589
 590   template<typename _Tp>
 591     inline const _Tp&
 592     real(const complex<_Tp>& __z)
 593     { return __z.real(); }
 594
 595   template<typename _Tp>
 596     inline _Tp&
 597     imag(complex<_Tp>& __z)
 598     { return __z.imag(); }
 599
 600   template<typename _Tp>
 601     inline const _Tp&
 602     imag(const complex<_Tp>& __z)
 603     { return __z.imag(); }
 604 #endif
 605
 606 #if _GLIBCXX_USE_C99_COMPLEX
 607 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
 608   inline _Float16
 609   __complex_abs(__complex__ _Float16 __z)
 610   { return _Float16(__builtin_cabsf(__z)); }
 611
 612   inline _Float16
 613   __complex_arg(__complex__ _Float16 __z)
 614   { return _Float16(__builtin_cargf(__z)); }
 615
 616   inline __complex__ _Float16
 617   __complex_cos(__complex__ _Float16 __z)
 618   { return static_cast<__complex__ _Float16>(__builtin_ccosf(__z)); }
 619
 620   inline __complex__ _Float16
 621   __complex_cosh(__complex__ _Float16 __z)
 622   { return static_cast<__complex__ _Float16>(__builtin_ccoshf(__z)); }
 623
 624   inline __complex__ _Float16
 625   __complex_exp(__complex__ _Float16 __z)
 626   { return static_cast<__complex__ _Float16>(__builtin_cexpf(__z)); }
 627
 628   inline __complex__ _Float16
 629   __complex_log(__complex__ _Float16 __z)
 630   { return static_cast<__complex__ _Float16>(__builtin_clogf(__z)); }
 631
 632   inline __complex__ _Float16
 633   __complex_sin(__complex__ _Float16 __z)
 634   { return static_cast<__complex__ _Float16>(__builtin_csinf(__z)); }
 635
 636   inline __complex__ _Float16
 637   __complex_sinh(__complex__ _Float16 __z)
 638   { return static_cast<__complex__ _Float16>(__builtin_csinhf(__z)); }
 639
 640   inline __complex__ _Float16
 641   __complex_sqrt(__complex__ _Float16 __z)
 642   { return static_cast<__complex__ _Float16>(__builtin_csqrtf(__z)); }
 643
 644   inline __complex__ _Float16
 645   __complex_tan(__complex__ _Float16 __z)
 646   { return static_cast<__complex__ _Float16>(__builtin_ctanf(__z)); }
 647
 648   inline __complex__ _Float16
 649   __complex_tanh(__complex__ _Float16 __z)
 650   { return static_cast<__complex__ _Float16>(__builtin_ctanhf(__z)); }
 651
 652   inline __complex__ _Float16
 653   __complex_pow(__complex__ _Float16 __x, __complex__ _Float16 __y)
 654   { return static_cast<__complex__ _Float16>(__builtin_cpowf(__x, __y)); }
 655 #endif
 656
 657 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
 658   inline _Float32
 659   __complex_abs(__complex__ _Float32 __z) { return __builtin_cabsf(__z); }
 660
 661   inline _Float32
 662   __complex_arg(__complex__ _Float32 __z) { return __builtin_cargf(__z); }
 663
 664   inline __complex__ _Float32
 665   __complex_cos(__complex__ _Float32 __z) { return __builtin_ccosf(__z); }
 666
 667   inline __complex__ _Float32
 668   __complex_cosh(__complex__ _Float32 __z) { return __builtin_ccoshf(__z); }
 669
 670   inline __complex__ _Float32
 671   __complex_exp(__complex__ _Float32 __z) { return __builtin_cexpf(__z); }
 672
 673   inline __complex__ _Float32
 674   __complex_log(__complex__ _Float32 __z) { return __builtin_clogf(__z); }
 675
 676   inline __complex__ _Float32
 677   __complex_sin(__complex__ _Float32 __z) { return __builtin_csinf(__z); }
 678
 679   inline __complex__ _Float32
 680   __complex_sinh(__complex__ _Float32 __z) { return __builtin_csinhf(__z); }
 681
 682   inline __complex__ _Float32
 683   __complex_sqrt(__complex__ _Float32 __z) { return __builtin_csqrtf(__z); }
 684
 685   inline __complex__ _Float32
 686   __complex_tan(__complex__ _Float32 __z) { return __builtin_ctanf(__z); }
 687
 688   inline __complex__ _Float32
 689   __complex_tanh(__complex__ _Float32 __z) { return __builtin_ctanhf(__z); }
 690
 691   inline __complex__ _Float32
 692   __complex_pow(__complex__ _Float32 __x, __complex__ _Float32 __y)
 693   { return __builtin_cpowf(__x, __y); }
 694 #endif
 695
 696 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
 697   inline _Float64
 698   __complex_abs(__complex__ _Float64 __z) { return __builtin_cabs(__z); }
 699
 700   inline _Float64
 701   __complex_arg(__complex__ _Float64 __z) { return __builtin_carg(__z); }
 702
 703   inline __complex__ _Float64
 704   __complex_cos(__complex__ _Float64 __z) { return __builtin_ccos(__z); }
 705
 706   inline __complex__ _Float64
 707   __complex_cosh(__complex__ _Float64 __z) { return __builtin_ccosh(__z); }
 708
 709   inline __complex__ _Float64
 710   __complex_exp(__complex__ _Float64 __z) { return __builtin_cexp(__z); }
 711
 712   inline __complex__ _Float64
 713   __complex_log(__complex__ _Float64 __z) { return __builtin_clog(__z); }
 714
 715   inline __complex__ _Float64
 716   __complex_sin(__complex__ _Float64 __z) { return __builtin_csin(__z); }
 717
 718   inline __complex__ _Float64
 719   __complex_sinh(__complex__ _Float64 __z) { return __builtin_csinh(__z); }
 720
 721   inline __complex__ _Float64
 722   __complex_sqrt(__complex__ _Float64 __z) { return __builtin_csqrt(__z); }
 723
 724   inline __complex__ _Float64
 725   __complex_tan(__complex__ _Float64 __z) { return __builtin_ctan(__z); }
 726
 727   inline __complex__ _Float64
 728   __complex_tanh(__complex__ _Float64 __z) { return __builtin_ctanh(__z); }
 729
 730   inline __complex__ _Float64
 731   __complex_pow(__complex__ _Float64 __x, __complex__ _Float64 __y)
 732   { return __builtin_cpow(__x, __y); }
 733 #endif
 734
 735 #if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
 736   inline _Float128
 737   __complex_abs(__complex__ _Float128 __z) { return __builtin_cabsl(__z); }
 738
 739   inline _Float128
 740   __complex_arg(__complex__ _Float128 __z) { return __builtin_cargl(__z); }
 741
 742   inline __complex__ _Float128
 743   __complex_cos(__complex__ _Float128 __z) { return __builtin_ccosl(__z); }
 744
 745   inline __complex__ _Float128
 746   __complex_cosh(__complex__ _Float128 __z) { return __builtin_ccoshl(__z); }
 747
 748   inline __complex__ _Float128
 749   __complex_exp(__complex__ _Float128 __z) { return __builtin_cexpl(__z); }
 750
 751   inline __complex__ _Float128
 752   __complex_log(__complex__ _Float128 __z) { return __builtin_clogl(__z); }
 753
 754   inline __complex__ _Float128
 755   __complex_sin(__complex__ _Float128 __z) { return __builtin_csinl(__z); }
 756
 757   inline __complex__ _Float128
 758   __complex_sinh(__complex__ _Float128 __z) { return __builtin_csinhl(__z); }
 759
 760   inline __complex__ _Float128
 761   __complex_sqrt(__complex__ _Float128 __z) { return __builtin_csqrtl(__z); }
 762
 763   inline __complex__ _Float128
 764   __complex_tan(__complex__ _Float128 __z) { return __builtin_ctanl(__z); }
 765
 766   inline __complex__ _Float128
 767   __complex_tanh(__complex__ _Float128 __z) { return __builtin_ctanhl(__z); }
 768
 769   inline __complex__ _Float128
 770   __complex_pow(__complex__ _Float128 __x, __complex__ _Float128 __y)
 771   { return __builtin_cpowl(__x, __y); }
 772 #elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
 773   inline _Float128
 774   __complex_abs(__complex__ _Float128 __z) { return __builtin_cabsf128(__z); }
 775
 776   inline _Float128
 777   __complex_arg(__complex__ _Float128 __z) { return __builtin_cargf128(__z); }
 778
 779   inline __complex__ _Float128
 780   __complex_cos(__complex__ _Float128 __z) { return __builtin_ccosf128(__z); }
 781
 782   inline __complex__ _Float128
 783   __complex_cosh(__complex__ _Float128 __z) { return __builtin_ccoshf128(__z); }
 784
 785   inline __complex__ _Float128
 786   __complex_exp(__complex__ _Float128 __z) { return __builtin_cexpf128(__z); }
 787
 788   inline __complex__ _Float128
 789   __complex_log(__complex__ _Float128 __z) { return __builtin_clogf128(__z); }
 790
 791   inline __complex__ _Float128
 792   __complex_sin(__complex__ _Float128 __z) { return __builtin_csinf128(__z); }
 793
 794   inline __complex__ _Float128
 795   __complex_sinh(__complex__ _Float128 __z) { return __builtin_csinhf128(__z); }
 796
 797   inline __complex__ _Float128
 798   __complex_sqrt(__complex__ _Float128 __z) { return __builtin_csqrtf128(__z); }
 799
 800   inline __complex__ _Float128
 801   __complex_tan(__complex__ _Float128 __z) { return __builtin_ctanf128(__z); }
 802
 803   inline __complex__ _Float128
 804   __complex_tanh(__complex__ _Float128 __z) { return __builtin_ctanhf128(__z); }
 805
 806   inline __complex__ _Float128
 807   __complex_pow(__complex__ _Float128 __x, __complex__ _Float128 __y)
 808   { return __builtin_cpowf128(__x, __y); }
 809 #endif
 810
 811 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
 812   inline __gnu_cxx::__bfloat16_t
 813   __complex_abs(__complex__ decltype(0.0bf16) __z)
 814   { return __gnu_cxx::__bfloat16_t(__builtin_cabsf(__z)); }
 815
 816   inline __gnu_cxx::__bfloat16_t
 817   __complex_arg(__complex__ decltype(0.0bf16) __z)
 818   { return __gnu_cxx::__bfloat16_t(__builtin_cargf(__z)); }
 819
 820   inline __complex__ decltype(0.0bf16)
 821   __complex_cos(__complex__ decltype(0.0bf16) __z)
 822   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_ccosf(__z)); }
 823
 824   inline __complex__ decltype(0.0bf16)
 825   __complex_cosh(__complex__ decltype(0.0bf16) __z)
 826   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_ccoshf(__z)); }
 827
 828   inline __complex__ decltype(0.0bf16)
 829   __complex_exp(__complex__ decltype(0.0bf16) __z)
 830   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_cexpf(__z)); }
 831
 832   inline __complex__ decltype(0.0bf16)
 833   __complex_log(__complex__ decltype(0.0bf16) __z)
 834   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_clogf(__z)); }
 835
 836   inline __complex__ decltype(0.0bf16)
 837   __complex_sin(__complex__ decltype(0.0bf16) __z)
 838   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_csinf(__z)); }
 839
 840   inline __complex__ decltype(0.0bf16)
 841   __complex_sinh(__complex__ decltype(0.0bf16) __z)
 842   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_csinhf(__z)); }
 843
 844   inline __complex__ decltype(0.0bf16)
 845   __complex_sqrt(__complex__ decltype(0.0bf16) __z)
 846   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_csqrtf(__z)); }
 847
 848   inline __complex__ decltype(0.0bf16)
 849   __complex_tan(__complex__ decltype(0.0bf16) __z)
 850   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_ctanf(__z)); }
 851
 852   inline __complex__ decltype(0.0bf16)
 853   __complex_tanh(__complex__ decltype(0.0bf16) __z)
 854   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_ctanhf(__z)); }
 855
 856   inline __complex__ decltype(0.0bf16)
 857   __complex_pow(__complex__ decltype(0.0bf16) __x,
 858                 __complex__ decltype(0.0bf16) __y)
 859   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_cpowf(__x,
 860                                                                       __y)); }
 861 #endif
 862 #endif
 863
 864   // 26.2.7/3 abs(__z):  Returns the magnitude of __z.
 865   template<typename _Tp>
 866     inline _Tp
 867     __complex_abs(const complex<_Tp>& __z)
 868     {
 869       _Tp __x = __z.real();
 870       _Tp __y = __z.imag();
 871       const _Tp __s = std::max(abs(__x), abs(__y));
 872       if (__s == _Tp())  // well ...
 873         return __s;
 874       __x /= __s;
 875       __y /= __s;
 876       return __s * sqrt(__x * __x + __y * __y);
 877     }
 878
 879 #if _GLIBCXX_USE_C99_COMPLEX
 880   inline float
 881   __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
 882
 883   inline double
 884   __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
 885
 886   inline long double
 887   __complex_abs(const __complex__ long double& __z)
 888   { return __builtin_cabsl(__z); }
 889
 890   template<typename _Tp>
 891     inline _Tp
 892     abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
 893 #else
 894   template<typename _Tp>
 895     inline _Tp
 896     abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
 897 #endif
 898
 899
 900   // 26.2.7/4: arg(__z): Returns the phase angle of __z.
 901   template<typename _Tp>
 902     inline _Tp
 903     __complex_arg(const complex<_Tp>& __z)
 904     { return  atan2(__z.imag(), __z.real()); }
 905
 906 #if _GLIBCXX_USE_C99_COMPLEX
 907   inline float
 908   __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
 909
 910   inline double
 911   __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
 912
 913   inline long double
 914   __complex_arg(const __complex__ long double& __z)
 915   { return __builtin_cargl(__z); }
 916
 917   template<typename _Tp>
 918     inline _Tp
 919     arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
 920 #else
 921   template<typename _Tp>
 922     inline _Tp
 923     arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
 924 #endif
 925
 926   // 26.2.7/5: norm(__z) returns the squared magnitude of __z.
 927   //     As defined, norm() is -not- a norm is the common mathematical
 928   //     sense used in numerics.  The helper class _Norm_helper<> tries to
 929   //     distinguish between builtin floating point and the rest, so as
 930   //     to deliver an answer as close as possible to the real value.
 931   template<bool>
 932     struct _Norm_helper
 933     {
 934       template<typename _Tp>
 935         static inline _GLIBCXX20_CONSTEXPR _Tp _S_do_it(const complex<_Tp>& __z)
 936         {
 937           const _Tp __x = __z.real();
 938           const _Tp __y = __z.imag();
 939           return __x * __x + __y * __y;
 940         }
 941     };
 942
 943   template<>
 944     struct _Norm_helper<true>
 945     {
 946       template<typename _Tp>
 947         static inline _GLIBCXX20_CONSTEXPR _Tp _S_do_it(const complex<_Tp>& __z)
 948         {
 949           //_Tp __res = std::abs(__z);
 950           //return __res * __res;
 951           const _Tp __x = __z.real();
 952           const _Tp __y = __z.imag();
 953           return __x * __x + __y * __y;
 954         }
 955     };
 956
 957   template<typename _Tp>
 958     inline _GLIBCXX20_CONSTEXPR _Tp
 959     norm(const complex<_Tp>& __z)
 960     {
 961       return _Norm_helper<__is_floating<_Tp>::__value
 962         && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
 963     }
 964
 965   template<typename _Tp>
 966     inline complex<_Tp>
 967     polar(const _Tp& __rho, const _Tp& __theta)
 968     {
 969       __glibcxx_assert( __rho >= 0 );
 970       return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta));
 971     }
 972
 973   template<typename _Tp>
 974     inline _GLIBCXX20_CONSTEXPR complex<_Tp>
 975     conj(const complex<_Tp>& __z)
 976     { return complex<_Tp>(__z.real(), -__z.imag()); }
 977
 978   // Transcendentals
 979
 980   // 26.2.8/1 cos(__z):  Returns the cosine of __z.
 981   template<typename _Tp>
 982     inline complex<_Tp>
 983     __complex_cos(const complex<_Tp>& __z)
 984     {
 985       const _Tp __x = __z.real();
 986       const _Tp __y = __z.imag();
 987       return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
 988     }
 989
 990 #if _GLIBCXX_USE_C99_COMPLEX
 991   inline __complex__ float
 992   __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
 993
 994   inline __complex__ double
 995   __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
 996
 997   inline __complex__ long double
 998   __complex_cos(const __complex__ long double& __z)
 999   { return __builtin_ccosl(__z); }
1000
1001   template<typename _Tp>
1002     inline complex<_Tp>
1003     cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
1004 #else
1005   template<typename _Tp>
1006     inline complex<_Tp>
1007     cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
1008 #endif
1009
1010   // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
1011   template<typename _Tp>
1012     inline complex<_Tp>
1013     __complex_cosh(const complex<_Tp>& __z)
1014     {
1015       const _Tp __x = __z.real();
1016       const _Tp __y = __z.imag();
1017       return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
1018     }
1019
1020 #if _GLIBCXX_USE_C99_COMPLEX
1021   inline __complex__ float
1022   __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
1023
1024   inline __complex__ double
1025   __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
1026
1027   inline __complex__ long double
1028   __complex_cosh(const __complex__ long double& __z)
1029   { return __builtin_ccoshl(__z); }
1030
1031   template<typename _Tp>
1032     inline complex<_Tp>
1033     cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
1034 #else
1035   template<typename _Tp>
1036     inline complex<_Tp>
1037     cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
1038 #endif
1039
1040   // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
1041   template<typename _Tp>
1042     inline complex<_Tp>
1043     __complex_exp(const complex<_Tp>& __z)
1044     { return std::polar<_Tp>(exp(__z.real()), __z.imag()); }
1045
1046 #if _GLIBCXX_USE_C99_COMPLEX
1047   inline __complex__ float
1048   __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
1049
1050   inline __complex__ double
1051   __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
1052
1053   inline __complex__ long double
1054   __complex_exp(const __complex__ long double& __z)
1055   { return __builtin_cexpl(__z); }
1056
1057   template<typename _Tp>
1058     inline complex<_Tp>
1059     exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
1060 #else
1061   template<typename _Tp>
1062     inline complex<_Tp>
1063     exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
1064 #endif
1065
1066   // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z.
1067   //                    The branch cut is along the negative axis.
1068   template<typename _Tp>
1069     inline complex<_Tp>
1070     __complex_log(const complex<_Tp>& __z)
1071     { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
1072
1073 #if _GLIBCXX_USE_C99_COMPLEX
1074   inline __complex__ float
1075   __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
1076
1077   inline __complex__ double
1078   __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
1079
1080   inline __complex__ long double
1081   __complex_log(const __complex__ long double& __z)
1082   { return __builtin_clogl(__z); }
1083
1084   template<typename _Tp>
1085     inline complex<_Tp>
1086     log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
1087 #else
1088   template<typename _Tp>
1089     inline complex<_Tp>
1090     log(const complex<_Tp>& __z) { return __complex_log(__z); }
1091 #endif
1092
1093   template<typename _Tp>
1094     inline complex<_Tp>
1095     log10(const complex<_Tp>& __z)
1096     { return std::log(__z) / log(_Tp(10.0)); }
1097
1098   // 26.2.8/10 sin(__z): Returns the sine of __z.
1099   template<typename _Tp>
1100     inline complex<_Tp>
1101     __complex_sin(const complex<_Tp>& __z)
1102     {
1103       const _Tp __x = __z.real();
1104       const _Tp __y = __z.imag();
1105       return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
1106     }
1107
1108 #if _GLIBCXX_USE_C99_COMPLEX
1109   inline __complex__ float
1110   __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
1111
1112   inline __complex__ double
1113   __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
1114
1115   inline __complex__ long double
1116   __complex_sin(const __complex__ long double& __z)
1117   { return __builtin_csinl(__z); }
1118
1119   template<typename _Tp>
1120     inline complex<_Tp>
1121     sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
1122 #else
1123   template<typename _Tp>
1124     inline complex<_Tp>
1125     sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
1126 #endif
1127
1128   // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
1129   template<typename _Tp>
1130     inline complex<_Tp>
1131     __complex_sinh(const complex<_Tp>& __z)
1132     {
1133       const _Tp __x = __z.real();
1134       const _Tp  __y = __z.imag();
1135       return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
1136     }
1137
1138 #if _GLIBCXX_USE_C99_COMPLEX
1139   inline __complex__ float
1140   __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
1141
1142   inline __complex__ double
1143   __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
1144
1145   inline __complex__ long double
1146   __complex_sinh(const __complex__ long double& __z)
1147   { return __builtin_csinhl(__z); }
1148
1149   template<typename _Tp>
1150     inline complex<_Tp>
1151     sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
1152 #else
1153   template<typename _Tp>
1154     inline complex<_Tp>
1155     sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
1156 #endif
1157
1158   // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
1159   //                     The branch cut is on the negative axis.
1160   template<typename _Tp>
1161     complex<_Tp>
1162     __complex_sqrt(const complex<_Tp>& __z)
1163     {
1164       _Tp __x = __z.real();
1165       _Tp __y = __z.imag();
1166
1167       if (__x == _Tp())
1168         {
1169           _Tp __t = sqrt(abs(__y) / 2);
1170           return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
1171         }
1172       else
1173         {
1174           _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
1175           _Tp __u = __t / 2;
1176           return __x > _Tp()
1177             ? complex<_Tp>(__u, __y / __t)
1178             : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
1179         }
1180     }
1181
1182 #if _GLIBCXX_USE_C99_COMPLEX
1183   inline __complex__ float
1184   __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
1185
1186   inline __complex__ double
1187   __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
1188
1189   inline __complex__ long double
1190   __complex_sqrt(const __complex__ long double& __z)
1191   { return __builtin_csqrtl(__z); }
1192
1193   template<typename _Tp>
1194     inline complex<_Tp>
1195     sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
1196 #else
1197   template<typename _Tp>
1198     inline complex<_Tp>
1199     sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
1200 #endif
1201
1202   // 26.2.8/14 tan(__z):  Return the complex tangent of __z.
1203
1204   template<typename _Tp>
1205     inline complex<_Tp>
1206     __complex_tan(const complex<_Tp>& __z)
1207     { return std::sin(__z) / std::cos(__z); }
1208
1209 #if _GLIBCXX_USE_C99_COMPLEX
1210   inline __complex__ float
1211   __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
1212
1213   inline __complex__ double
1214   __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
1215
1216   inline __complex__ long double
1217   __complex_tan(const __complex__ long double& __z)
1218   { return __builtin_ctanl(__z); }
1219
1220   template<typename _Tp>
1221     inline complex<_Tp>
1222     tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
1223 #else
1224   template<typename _Tp>
1225     inline complex<_Tp>
1226     tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
1227 #endif
1228
1229
1230   // 26.2.8/15 tanh(__z):  Returns the hyperbolic tangent of __z.
1231
1232   template<typename _Tp>
1233     inline complex<_Tp>
1234     __complex_tanh(const complex<_Tp>& __z)
1235     { return std::sinh(__z) / std::cosh(__z); }
1236
1237 #if _GLIBCXX_USE_C99_COMPLEX
1238   inline __complex__ float
1239   __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
1240
1241   inline __complex__ double
1242   __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
1243
1244   inline __complex__ long double
1245   __complex_tanh(const __complex__ long double& __z)
1246   { return __builtin_ctanhl(__z); }
1247
1248   template<typename _Tp>
1249     inline complex<_Tp>
1250     tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
1251 #else
1252   template<typename _Tp>
1253     inline complex<_Tp>
1254     tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
1255 #endif
1256
1257
1258   // 26.2.8/9  pow(__x, __y): Returns the complex power base of __x
1259   //                          raised to the __y-th power.  The branch
1260   //                          cut is on the negative axis.
1261   template<typename _Tp>
1262     complex<_Tp>
1263     __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
1264     {
1265       complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
1266
1267       while (__n >>= 1)
1268         {
1269           __x *= __x;
1270           if (__n % 2)
1271             __y *= __x;
1272         }
1273
1274       return __y;
1275     }
1276
1277   // In C++11 mode we used to implement the resolution of
1278   // DR 844. complex pow return type is ambiguous.
1279   // thus the following overload was disabled in that mode.  However, doing
1280   // that causes all sorts of issues, see, for example:
1281   //   http://gcc.gnu.org/ml/libstdc++/2013-01/msg00058.html
1282   // and also PR57974.
1283   template<typename _Tp>
1284     inline complex<_Tp>
1285     pow(const complex<_Tp>& __z, int __n)
1286     {
1287       return __n < 0
1288         ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(unsigned)__n)
1289         : std::__complex_pow_unsigned(__z, __n);
1290     }
1291
1292   template<typename _Tp>
1293     complex<_Tp>
1294     pow(const complex<_Tp>& __x, const _Tp& __y)
1295     {
1296 #if ! _GLIBCXX_USE_C99_COMPLEX
1297       if (__x == _Tp())
1298         return _Tp();
1299 #endif
1300       if (__x.imag() == _Tp() && __x.real() > _Tp())
1301         return pow(__x.real(), __y);
1302
1303       complex<_Tp> __t = std::log(__x);
1304       return std::polar<_Tp>(exp(__y * __t.real()), __y * __t.imag());
1305     }
1306
1307   template<typename _Tp>
1308     inline complex<_Tp>
1309     __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1310     { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
1311
1312 #if _GLIBCXX_USE_C99_COMPLEX
1313   inline __complex__ float
1314   __complex_pow(__complex__ float __x, __complex__ float __y)
1315   { return __builtin_cpowf(__x, __y); }
1316
1317   inline __complex__ double
1318   __complex_pow(__complex__ double __x, __complex__ double __y)
1319   { return __builtin_cpow(__x, __y); }
1320
1321   inline __complex__ long double
1322   __complex_pow(const __complex__ long double& __x,
1323                 const __complex__ long double& __y)
1324   { return __builtin_cpowl(__x, __y); }
1325
1326   template<typename _Tp>
1327     inline complex<_Tp>
1328     pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1329     { return __complex_pow(__x.__rep(), __y.__rep()); }
1330 #else
1331   template<typename _Tp>
1332     inline complex<_Tp>
1333     pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1334     { return __complex_pow(__x, __y); }
1335 #endif
1336
1337   template<typename _Tp>
1338     inline complex<_Tp>
1339     pow(const _Tp& __x, const complex<_Tp>& __y)
1340     {
1341       return __x > _Tp() ? std::polar<_Tp>(pow(__x, __y.real()),
1342                                            __y.imag() * log(__x))
1343                          : std::pow(complex<_Tp>(__x), __y);
1344     }
1345
1346   /// 26.2.3  complex specializations
1347   /// complex<float> specialization
1348   template<>
1349     class complex<float>
1350     {
1351     public:
1352       typedef float value_type;
1353       typedef __complex__ float _ComplexT;
1354
1355       _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1356
1357       _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f)
1358 #if __cplusplus >= 201103L
1359       : _M_value{ __r, __i } { }
1360 #else
1361       {
1362         __real__ _M_value = __r;
1363         __imag__ _M_value = __i;
1364       }
1365 #endif
1366
1367 #if __cplusplus >= 201103L
1368       _GLIBCXX14_CONSTEXPR complex(const complex&) = default;
1369 #endif
1370
1371 #if __cplusplus > 202002L
1372       template<typename _Up>
1373         explicit(!requires(_Up __u) { value_type{__u}; })
1374         constexpr complex(const complex<_Up>& __z)
1375         : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
1376 #else
1377       explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
1378       explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1379 #endif
1380
1381 #if __cplusplus >= 201103L
1382       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1383       // DR 387. std::complex over-encapsulated.
1384       __attribute ((__abi_tag__ ("cxx11")))
1385       constexpr float
1386       real() const { return __real__ _M_value; }
1387
1388       __attribute ((__abi_tag__ ("cxx11")))
1389       constexpr float
1390       imag() const { return __imag__ _M_value; }
1391 #else
1392       float&
1393       real() { return __real__ _M_value; }
1394
1395       const float&
1396       real() const { return __real__ _M_value; }
1397
1398       float&
1399       imag() { return __imag__ _M_value; }
1400
1401       const float&
1402       imag() const { return __imag__ _M_value; }
1403 #endif
1404
1405       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1406       // DR 387. std::complex over-encapsulated.
1407       _GLIBCXX20_CONSTEXPR void
1408       real(float __val) { __real__ _M_value = __val; }
1409
1410       _GLIBCXX20_CONSTEXPR void
1411       imag(float __val) { __imag__ _M_value = __val; }
1412
1413       _GLIBCXX20_CONSTEXPR complex&
1414       operator=(float __f)
1415       {
1416         _M_value = __f;
1417         return *this;
1418       }
1419
1420       _GLIBCXX20_CONSTEXPR complex&
1421       operator+=(float __f)
1422       {
1423         _M_value += __f;
1424         return *this;
1425       }
1426
1427       _GLIBCXX20_CONSTEXPR complex&
1428       operator-=(float __f)
1429       {
1430         _M_value -= __f;
1431         return *this;
1432       }
1433
1434       _GLIBCXX20_CONSTEXPR complex&
1435       operator*=(float __f)
1436       {
1437         _M_value *= __f;
1438         return *this;
1439       }
1440
1441       _GLIBCXX20_CONSTEXPR complex&
1442       operator/=(float __f)
1443       {
1444         _M_value /= __f;
1445         return *this;
1446       }
1447
1448       // Let the compiler synthesize the copy and assignment
1449       // operator.  It always does a pretty good job.
1450 #if __cplusplus >= 201103L
1451       _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1452 #endif
1453
1454       template<typename _Tp>
1455         _GLIBCXX20_CONSTEXPR complex&
1456         operator=(const complex<_Tp>&  __z)
1457         {
1458           __real__ _M_value = __z.real();
1459           __imag__ _M_value = __z.imag();
1460           return *this;
1461         }
1462
1463       template<typename _Tp>
1464         _GLIBCXX20_CONSTEXPR complex&
1465         operator+=(const complex<_Tp>& __z)
1466         {
1467           _M_value += __z.__rep();
1468           return *this;
1469         }
1470
1471       template<class _Tp>
1472         _GLIBCXX20_CONSTEXPR complex&
1473         operator-=(const complex<_Tp>& __z)
1474         {
1475           _M_value -= __z.__rep();
1476           return *this;
1477         }
1478
1479       template<class _Tp>
1480         _GLIBCXX20_CONSTEXPR complex&
1481         operator*=(const complex<_Tp>& __z)
1482         {
1483           const _ComplexT __t = __z.__rep();
1484           _M_value *= __t;
1485           return *this;
1486         }
1487
1488       template<class _Tp>
1489         _GLIBCXX20_CONSTEXPR complex&
1490         operator/=(const complex<_Tp>& __z)
1491         {
1492           const _ComplexT __t = __z.__rep();
1493           _M_value /= __t;
1494           return *this;
1495         }
1496
1497       _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1498
1499     private:
1500       _ComplexT _M_value;
1501     };
1502
1503   /// 26.2.3  complex specializations
1504   /// complex<double> specialization
1505   template<>
1506     class complex<double>
1507     {
1508     public:
1509       typedef double value_type;
1510       typedef __complex__ double _ComplexT;
1511
1512       _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1513
1514       _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
1515 #if __cplusplus >= 201103L
1516       : _M_value{ __r, __i } { }
1517 #else
1518       {
1519         __real__ _M_value = __r;
1520         __imag__ _M_value = __i;
1521       }
1522 #endif
1523
1524 #if __cplusplus >= 201103L
1525       _GLIBCXX14_CONSTEXPR complex(const complex&) = default;
1526 #endif
1527
1528 #if __cplusplus > 202002L
1529       template<typename _Up>
1530         explicit(!requires(_Up __u) { value_type{__u}; })
1531         constexpr complex(const complex<_Up>& __z)
1532         : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
1533 #else
1534       _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1535       : _M_value(__z.__rep()) { }
1536
1537       explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1538 #endif
1539
1540 #if __cplusplus >= 201103L
1541       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1542       // DR 387. std::complex over-encapsulated.
1543       __attribute ((__abi_tag__ ("cxx11")))
1544       constexpr double
1545       real() const { return __real__ _M_value; }
1546
1547       __attribute ((__abi_tag__ ("cxx11")))
1548       constexpr double
1549       imag() const { return __imag__ _M_value; }
1550 #else
1551       double&
1552       real() { return __real__ _M_value; }
1553
1554       const double&
1555       real() const { return __real__ _M_value; }
1556
1557       double&
1558       imag() { return __imag__ _M_value; }
1559
1560       const double&
1561       imag() const { return __imag__ _M_value; }
1562 #endif
1563
1564       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1565       // DR 387. std::complex over-encapsulated.
1566       _GLIBCXX20_CONSTEXPR void
1567       real(double __val) { __real__ _M_value = __val; }
1568
1569       _GLIBCXX20_CONSTEXPR void
1570       imag(double __val) { __imag__ _M_value = __val; }
1571
1572       _GLIBCXX20_CONSTEXPR complex&
1573       operator=(double __d)
1574       {
1575         _M_value = __d;
1576         return *this;
1577       }
1578
1579       _GLIBCXX20_CONSTEXPR complex&
1580       operator+=(double __d)
1581       {
1582         _M_value += __d;
1583         return *this;
1584       }
1585
1586       _GLIBCXX20_CONSTEXPR complex&
1587       operator-=(double __d)
1588       {
1589         _M_value -= __d;
1590         return *this;
1591       }
1592
1593       _GLIBCXX20_CONSTEXPR complex&
1594       operator*=(double __d)
1595       {
1596         _M_value *= __d;
1597         return *this;
1598       }
1599
1600       _GLIBCXX20_CONSTEXPR complex&
1601       operator/=(double __d)
1602       {
1603         _M_value /= __d;
1604         return *this;
1605       }
1606
1607       // The compiler will synthesize this, efficiently.
1608 #if __cplusplus >= 201103L
1609       _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1610 #endif
1611
1612       template<typename _Tp>
1613         _GLIBCXX20_CONSTEXPR complex&
1614         operator=(const complex<_Tp>& __z)
1615         {
1616           _M_value = __z.__rep();
1617           return *this;
1618         }
1619
1620       template<typename _Tp>
1621         _GLIBCXX20_CONSTEXPR complex&
1622         operator+=(const complex<_Tp>& __z)
1623         {
1624           _M_value += __z.__rep();
1625           return *this;
1626         }
1627
1628       template<typename _Tp>
1629         _GLIBCXX20_CONSTEXPR complex&
1630         operator-=(const complex<_Tp>& __z)
1631         {
1632           _M_value -= __z.__rep();
1633           return *this;
1634         }
1635
1636       template<typename _Tp>
1637         _GLIBCXX20_CONSTEXPR complex&
1638         operator*=(const complex<_Tp>& __z)
1639         {
1640           const _ComplexT __t = __z.__rep();
1641           _M_value *= __t;
1642           return *this;
1643         }
1644
1645       template<typename _Tp>
1646         _GLIBCXX20_CONSTEXPR complex&
1647         operator/=(const complex<_Tp>& __z)
1648         {
1649           const _ComplexT __t = __z.__rep();
1650           _M_value /= __t;
1651           return *this;
1652         }
1653
1654       _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1655
1656     private:
1657       _ComplexT _M_value;
1658     };
1659
1660   /// 26.2.3  complex specializations
1661   /// complex<long double> specialization
1662   template<>
1663     class complex<long double>
1664     {
1665     public:
1666       typedef long double value_type;
1667       typedef __complex__ long double _ComplexT;
1668
1669       _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1670
1671       _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L,
1672                                  long double __i = 0.0L)
1673 #if __cplusplus >= 201103L
1674       : _M_value{ __r, __i } { }
1675 #else
1676       {
1677         __real__ _M_value = __r;
1678         __imag__ _M_value = __i;
1679       }
1680 #endif
1681
1682 #if __cplusplus >= 201103L
1683       _GLIBCXX14_CONSTEXPR complex(const complex&) = default;
1684 #endif
1685
1686 #if __cplusplus > 202002L
1687       template<typename _Up>
1688         explicit(!requires(_Up __u) { value_type{__u}; })
1689         constexpr complex(const complex<_Up>& __z)
1690         : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
1691 #else
1692       _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1693       : _M_value(__z.__rep()) { }
1694
1695       _GLIBCXX_CONSTEXPR complex(const complex<double>& __z)
1696       : _M_value(__z.__rep()) { }
1697 #endif
1698
1699 #if __cplusplus >= 201103L
1700       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1701       // DR 387. std::complex over-encapsulated.
1702       __attribute ((__abi_tag__ ("cxx11")))
1703       constexpr long double
1704       real() const { return __real__ _M_value; }
1705
1706       __attribute ((__abi_tag__ ("cxx11")))
1707       constexpr long double
1708       imag() const { return __imag__ _M_value; }
1709 #else
1710       long double&
1711       real() { return __real__ _M_value; }
1712
1713       const long double&
1714       real() const { return __real__ _M_value; }
1715
1716       long double&
1717       imag() { return __imag__ _M_value; }
1718
1719       const long double&
1720       imag() const { return __imag__ _M_value; }
1721 #endif
1722
1723       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1724       // DR 387. std::complex over-encapsulated.
1725       _GLIBCXX20_CONSTEXPR void
1726       real(long double __val) { __real__ _M_value = __val; }
1727
1728       _GLIBCXX20_CONSTEXPR void
1729       imag(long double __val) { __imag__ _M_value = __val; }
1730
1731       _GLIBCXX20_CONSTEXPR complex&
1732       operator=(long double __r)
1733       {
1734         _M_value = __r;
1735         return *this;
1736       }
1737
1738       _GLIBCXX20_CONSTEXPR complex&
1739       operator+=(long double __r)
1740       {
1741         _M_value += __r;
1742         return *this;
1743       }
1744
1745       _GLIBCXX20_CONSTEXPR complex&
1746       operator-=(long double __r)
1747       {
1748         _M_value -= __r;
1749         return *this;
1750       }
1751
1752       _GLIBCXX20_CONSTEXPR complex&
1753       operator*=(long double __r)
1754       {
1755         _M_value *= __r;
1756         return *this;
1757       }
1758
1759       _GLIBCXX20_CONSTEXPR complex&
1760       operator/=(long double __r)
1761       {
1762         _M_value /= __r;
1763         return *this;
1764       }
1765
1766       // The compiler knows how to do this efficiently
1767 #if __cplusplus >= 201103L
1768       _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1769 #endif
1770
1771       template<typename _Tp>
1772         _GLIBCXX20_CONSTEXPR complex&
1773         operator=(const complex<_Tp>& __z)
1774         {
1775           _M_value = __z.__rep();
1776           return *this;
1777         }
1778
1779       template<typename _Tp>
1780         _GLIBCXX20_CONSTEXPR complex&
1781         operator+=(const complex<_Tp>& __z)
1782         {
1783           _M_value += __z.__rep();
1784           return *this;
1785         }
1786
1787       template<typename _Tp>
1788         _GLIBCXX20_CONSTEXPR complex&
1789         operator-=(const complex<_Tp>& __z)
1790         {
1791           _M_value -= __z.__rep();
1792           return *this;
1793         }
1794
1795       template<typename _Tp>
1796         _GLIBCXX20_CONSTEXPR complex&
1797         operator*=(const complex<_Tp>& __z)
1798         {
1799           const _ComplexT __t = __z.__rep();
1800           _M_value *= __t;
1801           return *this;
1802         }
1803
1804       template<typename _Tp>
1805         _GLIBCXX20_CONSTEXPR complex&
1806         operator/=(const complex<_Tp>& __z)
1807         {
1808           const _ComplexT __t = __z.__rep();
1809           _M_value /= __t;
1810           return *this;
1811         }
1812
1813       _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1814
1815     private:
1816       _ComplexT _M_value;
1817     };
1818
1819 #if __cplusplus > 202002L
1820   template<typename _Tp>
1821     struct __complex_type
1822     { };
1823
1824 #ifdef __STDCPP_FLOAT16_T__
1825   template<>
1826     struct __complex_type<_Float16>
1827     { typedef __complex__ _Float16 type; };
1828 #endif
1829
1830 #ifdef __STDCPP_FLOAT32_T__
1831   template<>
1832     struct __complex_type<_Float32>
1833     { typedef __complex__ _Float32 type; };
1834 #endif
1835
1836 #ifdef __STDCPP_FLOAT64_T__
1837   template<>
1838     struct __complex_type<_Float64>
1839     { typedef __complex__ _Float64 type; };
1840 #endif
1841
1842 #ifdef __STDCPP_FLOAT128_T__
1843   template<>
1844     struct __complex_type<_Float128>
1845     { typedef __complex__ _Float128 type; };
1846 #endif
1847
1848 #ifdef __STDCPP_BFLOAT16_T__
1849   template<>
1850     struct __complex_type<__gnu_cxx::__bfloat16_t>
1851     { typedef __complex__ decltype(0.0bf16) type; };
1852 #endif
1853
1854   template<typename _Tp>
1855     requires requires { typename __complex_type<_Tp>::type; }
1856     class complex<_Tp>
1857     {
1858     public:
1859       typedef _Tp value_type;
1860       typedef typename std::__complex_type<_Tp>::type _ComplexT;
1861
1862       constexpr complex(_ComplexT __z) : _M_value(__z) { }
1863
1864       constexpr complex(_Tp __r = _Tp(), _Tp __i = _Tp())
1865       : _M_value{ __r, __i } { }
1866
1867       template<typename _Up>
1868         explicit(!requires(_Up __u) { value_type{__u}; })
1869         constexpr complex(const complex<_Up>& __z)
1870         : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
1871
1872       constexpr _Tp
1873       real() const { return __real__ _M_value; }
1874
1875       constexpr _Tp
1876       imag() const { return __imag__ _M_value; }
1877
1878       constexpr void
1879       real(_Tp __val) { __real__ _M_value = __val; }
1880
1881       constexpr void
1882       imag(_Tp __val) { __imag__ _M_value = __val; }
1883
1884       constexpr complex&
1885       operator=(_Tp __f)
1886       {
1887         _M_value = __f;
1888         return *this;
1889       }
1890
1891       constexpr complex&
1892       operator+=(_Tp __f)
1893       {
1894         _M_value += __f;
1895         return *this;
1896       }
1897
1898       constexpr complex&
1899       operator-=(_Tp __f)
1900       {
1901         _M_value -= __f;
1902         return *this;
1903       }
1904
1905       constexpr complex&
1906       operator*=(_Tp __f)
1907       {
1908         _M_value *= __f;
1909         return *this;
1910       }
1911
1912       constexpr complex&
1913       operator/=(_Tp __f)
1914       {
1915         _M_value /= __f;
1916         return *this;
1917       }
1918
1919       // Let the compiler synthesize the copy and assignment
1920       // operator.  It always does a pretty good job.
1921       constexpr complex(const complex&) = default;
1922       constexpr complex& operator=(const complex&) = default;
1923
1924       template<typename _Up>
1925         constexpr complex&
1926         operator=(const complex<_Up>&  __z)
1927         {
1928           __real__ _M_value = __z.real();
1929           __imag__ _M_value = __z.imag();
1930           return *this;
1931         }
1932
1933       template<typename _Up>
1934         constexpr complex&
1935         operator+=(const complex<_Up>& __z)
1936         {
1937           _M_value += __z.__rep();
1938           return *this;
1939         }
1940
1941       template<class _Up>
1942         constexpr complex&
1943         operator-=(const complex<_Up>& __z)
1944         {
1945           _M_value -= __z.__rep();
1946           return *this;
1947         }
1948
1949       template<class _Up>
1950         constexpr complex&
1951         operator*=(const complex<_Up>& __z)
1952         {
1953           const _ComplexT __t = __z.__rep();
1954           _M_value *= __t;
1955           return *this;
1956         }
1957
1958       template<class _Up>
1959         constexpr complex&
1960         operator/=(const complex<_Up>& __z)
1961         {
1962           const _ComplexT __t = __z.__rep();
1963           _M_value /= __t;
1964           return *this;
1965         }
1966
1967       constexpr _ComplexT __rep() const { return _M_value; }
1968
1969     private:
1970       _ComplexT _M_value;
1971     };
1972 #endif
1973
1974 #if __cplusplus <= 202002L
1975   // These bits have to be at the end of this file, so that the
1976   // specializations have all been defined.
1977   inline _GLIBCXX_CONSTEXPR
1978   complex<float>::complex(const complex<double>& __z)
1979   : _M_value(__z.__rep()) { }
1980
1981   inline _GLIBCXX_CONSTEXPR
1982   complex<float>::complex(const complex<long double>& __z)
1983   : _M_value(__z.__rep()) { }
1984
1985   inline _GLIBCXX_CONSTEXPR
1986   complex<double>::complex(const complex<long double>& __z)
1987   : _M_value(__z.__rep()) { }
1988 #endif
1989
1990   // Inhibit implicit instantiations for required instantiations,
1991   // which are defined via explicit instantiations elsewhere.
1992   // NB:  This syntax is a GNU extension.
1993 #if _GLIBCXX_EXTERN_TEMPLATE
1994   extern template istream& operator>>(istream&, complex<float>&);
1995   extern template ostream& operator<<(ostream&, const complex<float>&);
1996   extern template istream& operator>>(istream&, complex<double>&);
1997   extern template ostream& operator<<(ostream&, const complex<double>&);
1998   extern template istream& operator>>(istream&, complex<long double>&);
1999   extern template ostream& operator<<(ostream&, const complex<long double>&);
2000
2001 #ifdef _GLIBCXX_USE_WCHAR_T
2002   extern template wistream& operator>>(wistream&, complex<float>&);
2003   extern template wostream& operator<<(wostream&, const complex<float>&);
2004   extern template wistream& operator>>(wistream&, complex<double>&);
2005   extern template wostream& operator<<(wostream&, const complex<double>&);
2006   extern template wistream& operator>>(wistream&, complex<long double>&);
2007   extern template wostream& operator<<(wostream&, const complex<long double>&);
2008 #endif
2009 #endif
2010
2011   /// @} group complex_numbers
2012
2013 _GLIBCXX_END_NAMESPACE_VERSION
2014 } // namespace
2015
2016 #if __cplusplus >= 201103L
2017
2018 namespace std _GLIBCXX_VISIBILITY(default)
2019 {
2020 _GLIBCXX_BEGIN_NAMESPACE_VERSION
2021
2022   // Forward declarations.
2023   template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
2024   template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
2025   template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
2026
2027   template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
2028   template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
2029   template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
2030   // DR 595.
2031   template<typename _Tp> _Tp               fabs(const std::complex<_Tp>&);
2032
2033   template<typename _Tp>
2034     inline std::complex<_Tp>
2035     __complex_acos(const std::complex<_Tp>& __z)
2036     {
2037       const std::complex<_Tp> __t = std::asin(__z);
2038       const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
2039       return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
2040     }
2041
2042 #if _GLIBCXX_USE_C99_COMPLEX_ARC
2043 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2044   inline __complex__ _Float16
2045   __complex_acos(__complex__ _Float16 __z)
2046   { return static_cast<__complex__ _Float16>(__builtin_cacosf(__z)); }
2047
2048   inline __complex__ _Float16
2049   __complex_asin(__complex__ _Float16 __z)
2050   { return static_cast<__complex__ _Float16>(__builtin_casinf(__z)); }
2051
2052   inline __complex__ _Float16
2053   __complex_atan(__complex__ _Float16 __z)
2054   { return static_cast<__complex__ _Float16>(__builtin_catanf(__z)); }
2055
2056   inline __complex__ _Float16
2057   __complex_acosh(__complex__ _Float16 __z)
2058   { return static_cast<__complex__ _Float16>(__builtin_cacoshf(__z)); }
2059
2060   inline __complex__ _Float16
2061   __complex_asinh(__complex__ _Float16 __z)
2062   { return static_cast<__complex__ _Float16>(__builtin_casinhf(__z)); }
2063
2064   inline __complex__ _Float16
2065   __complex_atanh(__complex__ _Float16 __z)
2066   { return static_cast<__complex__ _Float16>(__builtin_catanhf(__z)); }
2067 #endif
2068
2069 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2070   inline __complex__ _Float32
2071   __complex_acos(__complex__ _Float32 __z)
2072   { return __builtin_cacosf(__z); }
2073
2074   inline __complex__ _Float32
2075   __complex_asin(__complex__ _Float32 __z)
2076   { return __builtin_casinf(__z); }
2077
2078   inline __complex__ _Float32
2079   __complex_atan(__complex__ _Float32 __z)
2080   { return __builtin_catanf(__z); }
2081
2082   inline __complex__ _Float32
2083   __complex_acosh(__complex__ _Float32 __z)
2084   { return __builtin_cacoshf(__z); }
2085
2086   inline __complex__ _Float32
2087   __complex_asinh(__complex__ _Float32 __z)
2088   { return __builtin_casinhf(__z); }
2089
2090   inline __complex__ _Float32
2091   __complex_atanh(__complex__ _Float32 __z)
2092   { return __builtin_catanhf(__z); }
2093 #endif
2094
2095 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2096   inline __complex__ _Float64
2097   __complex_acos(__complex__ _Float64 __z)
2098   { return __builtin_cacos(__z); }
2099
2100   inline __complex__ _Float64
2101   __complex_asin(__complex__ _Float64 __z)
2102   { return __builtin_casin(__z); }
2103
2104   inline __complex__ _Float64
2105   __complex_atan(__complex__ _Float64 __z)
2106   { return __builtin_catan(__z); }
2107
2108   inline __complex__ _Float64
2109   __complex_acosh(__complex__ _Float64 __z)
2110   { return __builtin_cacosh(__z); }
2111
2112   inline __complex__ _Float64
2113   __complex_asinh(__complex__ _Float64 __z)
2114   { return __builtin_casinh(__z); }
2115
2116   inline __complex__ _Float64
2117   __complex_atanh(__complex__ _Float64 __z)
2118   { return __builtin_catanh(__z); }
2119 #endif
2120
2121 #if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
2122   inline __complex__ _Float128
2123   __complex_acos(__complex__ _Float128 __z)
2124   { return __builtin_cacosl(__z); }
2125
2126   inline __complex__ _Float128
2127   __complex_asin(__complex__ _Float128 __z)
2128   { return __builtin_casinl(__z); }
2129
2130   inline __complex__ _Float128
2131   __complex_atan(__complex__ _Float128 __z)
2132   { return __builtin_catanl(__z); }
2133
2134   inline __complex__ _Float128
2135   __complex_acosh(__complex__ _Float128 __z)
2136   { return __builtin_cacoshl(__z); }
2137
2138   inline __complex__ _Float128
2139   __complex_asinh(__complex__ _Float128 __z)
2140   { return __builtin_casinhl(__z); }
2141
2142   inline __complex__ _Float128
2143   __complex_atanh(__complex__ _Float128 __z)
2144   { return __builtin_catanhl(__z); }
2145 #elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
2146   inline __complex__ _Float128
2147   __complex_acos(__complex__ _Float128 __z)
2148   { return __builtin_cacosf128(__z); }
2149
2150   inline __complex__ _Float128
2151   __complex_asin(__complex__ _Float128 __z)
2152   { return __builtin_casinf128(__z); }
2153
2154   inline __complex__ _Float128
2155   __complex_atan(__complex__ _Float128 __z)
2156   { return __builtin_catanf128(__z); }
2157
2158   inline __complex__ _Float128
2159   __complex_acosh(__complex__ _Float128 __z)
2160   { return __builtin_cacoshf128(__z); }
2161
2162   inline __complex__ _Float128
2163   __complex_asinh(__complex__ _Float128 __z)
2164   { return __builtin_casinhf128(__z); }
2165
2166   inline __complex__ _Float128
2167   __complex_atanh(__complex__ _Float128 __z)
2168   { return __builtin_catanhf128(__z); }
2169 #endif
2170
2171 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2172   inline __complex__ decltype(0.0bf16)
2173   __complex_acos(__complex__ decltype(0.0bf16) __z)
2174   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_cacosf(__z)); }
2175
2176   inline __complex__ decltype(0.0bf16)
2177   __complex_asin(__complex__ decltype(0.0bf16) __z)
2178   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_casinf(__z)); }
2179
2180   inline __complex__ decltype(0.0bf16)
2181   __complex_atan(__complex__ decltype(0.0bf16) __z)
2182   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_catanf(__z)); }
2183
2184   inline __complex__ decltype(0.0bf16)
2185   __complex_acosh(__complex__ decltype(0.0bf16) __z)
2186   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_cacoshf(__z)); }
2187
2188   inline __complex__ decltype(0.0bf16)
2189   __complex_asinh(__complex__ decltype(0.0bf16) __z)
2190   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_casinhf(__z)); }
2191
2192   inline __complex__ decltype(0.0bf16)
2193   __complex_atanh(__complex__ decltype(0.0bf16) __z)
2194   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_catanhf(__z)); }
2195 #endif
2196 #endif
2197
2198 #if _GLIBCXX_USE_C99_COMPLEX_ARC
2199   inline __complex__ float
2200   __complex_acos(__complex__ float __z)
2201   { return __builtin_cacosf(__z); }
2202
2203   inline __complex__ double
2204   __complex_acos(__complex__ double __z)
2205   { return __builtin_cacos(__z); }
2206
2207   inline __complex__ long double
2208   __complex_acos(const __complex__ long double& __z)
2209   { return __builtin_cacosl(__z); }
2210
2211   template<typename _Tp>
2212     inline std::complex<_Tp>
2213     acos(const std::complex<_Tp>& __z)
2214     { return __complex_acos(__z.__rep()); }
2215 #else
2216   /// acos(__z) [8.1.2].
2217   //  Effects:  Behaves the same as C99 function cacos, defined
2218   //            in subclause 7.3.5.1.
2219   template<typename _Tp>
2220     inline std::complex<_Tp>
2221     acos(const std::complex<_Tp>& __z)
2222     { return __complex_acos(__z); }
2223 #endif
2224
2225   template<typename _Tp>
2226     inline std::complex<_Tp>
2227     __complex_asin(const std::complex<_Tp>& __z)
2228     {
2229       std::complex<_Tp> __t(-__z.imag(), __z.real());
2230       __t = std::asinh(__t);
2231       return std::complex<_Tp>(__t.imag(), -__t.real());
2232     }
2233
2234 #if _GLIBCXX_USE_C99_COMPLEX_ARC
2235   inline __complex__ float
2236   __complex_asin(__complex__ float __z)
2237   { return __builtin_casinf(__z); }
2238
2239   inline __complex__ double
2240   __complex_asin(__complex__ double __z)
2241   { return __builtin_casin(__z); }
2242
2243   inline __complex__ long double
2244   __complex_asin(const __complex__ long double& __z)
2245   { return __builtin_casinl(__z); }
2246
2247   template<typename _Tp>
2248     inline std::complex<_Tp>
2249     asin(const std::complex<_Tp>& __z)
2250     { return __complex_asin(__z.__rep()); }
2251 #else
2252   /// asin(__z) [8.1.3].
2253   //  Effects:  Behaves the same as C99 function casin, defined
2254   //            in subclause 7.3.5.2.
2255   template<typename _Tp>
2256     inline std::complex<_Tp>
2257     asin(const std::complex<_Tp>& __z)
2258     { return __complex_asin(__z); }
2259 #endif
2260
2261   template<typename _Tp>
2262     std::complex<_Tp>
2263     __complex_atan(const std::complex<_Tp>& __z)
2264     {
2265       const _Tp __r2 = __z.real() * __z.real();
2266       const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
2267
2268       _Tp __num = __z.imag() + _Tp(1.0);
2269       _Tp __den = __z.imag() - _Tp(1.0);
2270
2271       __num = __r2 + __num * __num;
2272       __den = __r2 + __den * __den;
2273
2274       return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
2275                                _Tp(0.25) * log(__num / __den));
2276     }
2277
2278 #if _GLIBCXX_USE_C99_COMPLEX_ARC
2279   inline __complex__ float
2280   __complex_atan(__complex__ float __z)
2281   { return __builtin_catanf(__z); }
2282
2283   inline __complex__ double
2284   __complex_atan(__complex__ double __z)
2285   { return __builtin_catan(__z); }
2286
2287   inline __complex__ long double
2288   __complex_atan(const __complex__ long double& __z)
2289   { return __builtin_catanl(__z); }
2290
2291   template<typename _Tp>
2292     inline std::complex<_Tp>
2293     atan(const std::complex<_Tp>& __z)
2294     { return __complex_atan(__z.__rep()); }
2295 #else
2296   /// atan(__z) [8.1.4].
2297   //  Effects:  Behaves the same as C99 function catan, defined
2298   //            in subclause 7.3.5.3.
2299   template<typename _Tp>
2300     inline std::complex<_Tp>
2301     atan(const std::complex<_Tp>& __z)
2302     { return __complex_atan(__z); }
2303 #endif
2304
2305   template<typename _Tp>
2306     std::complex<_Tp>
2307     __complex_acosh(const std::complex<_Tp>& __z)
2308     {
2309       // Kahan's formula.
2310       return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
2311                                  + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
2312     }
2313
2314 #if _GLIBCXX_USE_C99_COMPLEX_ARC
2315   inline __complex__ float
2316   __complex_acosh(__complex__ float __z)
2317   { return __builtin_cacoshf(__z); }
2318
2319   inline __complex__ double
2320   __complex_acosh(__complex__ double __z)
2321   { return __builtin_cacosh(__z); }
2322
2323   inline __complex__ long double
2324   __complex_acosh(const __complex__ long double& __z)
2325   { return __builtin_cacoshl(__z); }
2326
2327   template<typename _Tp>
2328     inline std::complex<_Tp>
2329     acosh(const std::complex<_Tp>& __z)
2330     { return __complex_acosh(__z.__rep()); }
2331 #else
2332   /// acosh(__z) [8.1.5].
2333   //  Effects:  Behaves the same as C99 function cacosh, defined
2334   //            in subclause 7.3.6.1.
2335   template<typename _Tp>
2336     inline std::complex<_Tp>
2337     acosh(const std::complex<_Tp>& __z)
2338     { return __complex_acosh(__z); }
2339 #endif
2340
2341   template<typename _Tp>
2342     std::complex<_Tp>
2343     __complex_asinh(const std::complex<_Tp>& __z)
2344     {
2345       std::complex<_Tp> __t((__z.real() - __z.imag())
2346                             * (__z.real() + __z.imag()) + _Tp(1.0),
2347                             _Tp(2.0) * __z.real() * __z.imag());
2348       __t = std::sqrt(__t);
2349
2350       return std::log(__t + __z);
2351     }
2352
2353 #if _GLIBCXX_USE_C99_COMPLEX_ARC
2354   inline __complex__ float
2355   __complex_asinh(__complex__ float __z)
2356   { return __builtin_casinhf(__z); }
2357
2358   inline __complex__ double
2359   __complex_asinh(__complex__ double __z)
2360   { return __builtin_casinh(__z); }
2361
2362   inline __complex__ long double
2363   __complex_asinh(const __complex__ long double& __z)
2364   { return __builtin_casinhl(__z); }
2365
2366   template<typename _Tp>
2367     inline std::complex<_Tp>
2368     asinh(const std::complex<_Tp>& __z)
2369     { return __complex_asinh(__z.__rep()); }
2370 #else
2371   /// asinh(__z) [8.1.6].
2372   //  Effects:  Behaves the same as C99 function casin, defined
2373   //            in subclause 7.3.6.2.
2374   template<typename _Tp>
2375     inline std::complex<_Tp>
2376     asinh(const std::complex<_Tp>& __z)
2377     { return __complex_asinh(__z); }
2378 #endif
2379
2380   template<typename _Tp>
2381     std::complex<_Tp>
2382     __complex_atanh(const std::complex<_Tp>& __z)
2383     {
2384       const _Tp __i2 = __z.imag() * __z.imag();
2385       const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
2386
2387       _Tp __num = _Tp(1.0) + __z.real();
2388       _Tp __den = _Tp(1.0) - __z.real();
2389
2390       __num = __i2 + __num * __num;
2391       __den = __i2 + __den * __den;
2392
2393       return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
2394                                _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
2395     }
2396
2397 #if _GLIBCXX_USE_C99_COMPLEX_ARC
2398   inline __complex__ float
2399   __complex_atanh(__complex__ float __z)
2400   { return __builtin_catanhf(__z); }
2401
2402   inline __complex__ double
2403   __complex_atanh(__complex__ double __z)
2404   { return __builtin_catanh(__z); }
2405
2406   inline __complex__ long double
2407   __complex_atanh(const __complex__ long double& __z)
2408   { return __builtin_catanhl(__z); }
2409
2410   template<typename _Tp>
2411     inline std::complex<_Tp>
2412     atanh(const std::complex<_Tp>& __z)
2413     { return __complex_atanh(__z.__rep()); }
2414 #else
2415   /// atanh(__z) [8.1.7].
2416   //  Effects:  Behaves the same as C99 function catanh, defined
2417   //            in subclause 7.3.6.3.
2418   template<typename _Tp>
2419     inline std::complex<_Tp>
2420     atanh(const std::complex<_Tp>& __z)
2421     { return __complex_atanh(__z); }
2422 #endif
2423
2424   template<typename _Tp>
2425     inline _Tp
2426     /// fabs(__z) [8.1.8].
2427     //  Effects:  Behaves the same as C99 function cabs, defined
2428     //            in subclause 7.3.8.1.
2429     fabs(const std::complex<_Tp>& __z)
2430     { return std::abs(__z); }
2431
2432   /// Additional overloads [8.1.9].
2433   template<typename _Tp>
2434     inline typename __gnu_cxx::__promote<_Tp>::__type
2435     arg(_Tp __x)
2436     {
2437       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2438 #if (_GLIBCXX11_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
2439       return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
2440                                : __type();
2441 #else
2442       return std::arg(std::complex<__type>(__x));
2443 #endif
2444     }
2445
2446   template<typename _Tp>
2447     _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
2448     imag(_Tp)
2449     { return _Tp(); }
2450
2451   template<typename _Tp>
2452     _GLIBCXX20_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
2453     norm(_Tp __x)
2454     {
2455       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2456       return __type(__x) * __type(__x);
2457     }
2458
2459   template<typename _Tp>
2460     _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
2461     real(_Tp __x)
2462     { return __x; }
2463
2464   template<typename _Tp, typename _Up>
2465     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
2466     pow(const std::complex<_Tp>& __x, const _Up& __y)
2467     {
2468       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2469       return std::pow(std::complex<__type>(__x), __type(__y));
2470     }
2471
2472   template<typename _Tp, typename _Up>
2473     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
2474     pow(const _Tp& __x, const std::complex<_Up>& __y)
2475     {
2476       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2477       return std::pow(__type(__x), std::complex<__type>(__y));
2478     }
2479
2480   template<typename _Tp, typename _Up>
2481     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
2482     pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
2483     {
2484       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2485       return std::pow(std::complex<__type>(__x),
2486                       std::complex<__type>(__y));
2487     }
2488
2489   // Forward declarations.
2490   // DR 781.
2491   template<typename _Tp>
2492     std::complex<_Tp> proj(const std::complex<_Tp>&);
2493
2494   // Generic implementation of std::proj, does not work for infinities.
2495   template<typename _Tp>
2496     inline std::complex<_Tp>
2497     __complex_proj(const std::complex<_Tp>& __z)
2498     { return __z; }
2499
2500 #if _GLIBCXX_USE_C99_COMPLEX
2501   inline complex<float>
2502   __complex_proj(const complex<float>& __z)
2503   { return __builtin_cprojf(__z.__rep()); }
2504
2505   inline complex<double>
2506   __complex_proj(const complex<double>& __z)
2507   { return __builtin_cproj(__z.__rep()); }
2508
2509   inline complex<long double>
2510   __complex_proj(const complex<long double>& __z)
2511   { return __builtin_cprojl(__z.__rep()); }
2512
2513 #if __cplusplus > 202002L
2514 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2515   inline __complex__ _Float16
2516   __complex_proj(__complex__ _Float16 __z)
2517   { return static_cast<__complex__ _Float16>(__builtin_cprojf(__z)); }
2518 #endif
2519
2520 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2521   inline __complex__ _Float32
2522   __complex_proj(__complex__ _Float32 __z)
2523   { return __builtin_cprojf(__z); }
2524 #endif
2525
2526 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2527   inline __complex__ _Float64
2528   __complex_proj(__complex__ _Float64 __z)
2529   { return __builtin_cproj(__z); }
2530 #endif
2531
2532 #if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
2533   inline __complex__ _Float128
2534   __complex_proj(__complex__ _Float128 __z)
2535   { return __builtin_cprojl(__z); }
2536 #elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
2537   inline __complex__ _Float128
2538   __complex_proj(__complex__ _Float128 __z)
2539   { return __builtin_cprojf128(__z); }
2540 #endif
2541
2542 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2543   inline __complex__ decltype(0.0bf16)
2544   __complex_proj(__complex__ decltype(0.0bf16) __z)
2545   { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_cprojf(__z)); }
2546 #endif
2547
2548   template<typename _Tp>
2549     requires requires { typename __complex_type<_Tp>::type; }
2550     inline complex<_Tp>
2551     __complex_proj(const complex<_Tp>& __z)
2552     { return __complex_proj(__z.__rep()); }
2553 #endif
2554
2555 #elif defined _GLIBCXX_USE_C99_MATH_FUNCS
2556   inline complex<float>
2557   __complex_proj(const complex<float>& __z)
2558   {
2559     if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
2560       return complex<float>(__builtin_inff(),
2561                             __builtin_copysignf(0.0f, __z.imag()));
2562     return __z;
2563   }
2564
2565   inline complex<double>
2566   __complex_proj(const complex<double>& __z)
2567   {
2568     if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
2569       return complex<double>(__builtin_inf(),
2570                              __builtin_copysign(0.0, __z.imag()));
2571     return __z;
2572   }
2573
2574   inline complex<long double>
2575   __complex_proj(const complex<long double>& __z)
2576   {
2577     if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
2578       return complex<long double>(__builtin_infl(),
2579                                   __builtin_copysignl(0.0l, __z.imag()));
2580     return __z;
2581   }
2582 #endif
2583
2584   template<typename _Tp>
2585     inline std::complex<_Tp>
2586     proj(const std::complex<_Tp>& __z)
2587     { return __complex_proj(__z); }
2588
2589   // Overload for scalars
2590   template<typename _Tp>
2591     inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
2592     proj(_Tp __x)
2593     {
2594       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2595       return std::proj(std::complex<__type>(__x));
2596     }
2597
2598   template<typename _Tp>
2599     inline _GLIBCXX20_CONSTEXPR
2600         std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
2601     conj(_Tp __x)
2602     {
2603       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2604       return std::complex<__type>(__x, -__type());
2605     }
2606
2607 #ifdef __cpp_lib_complex_udls // C++ >= 14
2608
2609 inline namespace literals {
2610 inline namespace complex_literals {
2611 #pragma GCC diagnostic push
2612 #pragma GCC diagnostic ignored "-Wliteral-suffix"
2613
2614   constexpr std::complex<float>
2615   operator""if(long double __num)
2616   { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
2617
2618   constexpr std::complex<float>
2619   operator""if(unsigned long long __num)
2620   { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
2621
2622   constexpr std::complex<double>
2623   operator""i(long double __num)
2624   { return std::complex<double>{0.0, static_cast<double>(__num)}; }
2625
2626   constexpr std::complex<double>
2627   operator""i(unsigned long long __num)
2628   { return std::complex<double>{0.0, static_cast<double>(__num)}; }
2629
2630   constexpr std::complex<long double>
2631   operator""il(long double __num)
2632   { return std::complex<long double>{0.0L, __num}; }
2633
2634   constexpr std::complex<long double>
2635   operator""il(unsigned long long __num)
2636   { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }
2637
2638 #pragma GCC diagnostic pop
2639 } // inline namespace complex_literals
2640 } // inline namespace literals
2641
2642 #endif // __cpp_lib_complex_udls
2643
2644 _GLIBCXX_END_NAMESPACE_VERSION
2645 } // namespace
2646
2647 #endif  // C++11
2648
2649 #ifdef __clang__
2650 #pragma clang diagnostic pop
2651 #endif
2652
2653 #endif  /* _GLIBCXX_COMPLEX */