Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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