LCOV - code coverage report
Current view: top level - usr/include/c++/4.8 - complex (source / functions) Hit Total Coverage
Test: coverage.info Lines: 53 56 94.6 %
Date: 2013-07-07 Functions: 22 23 95.7 %
Branches: 0 0 -

           Branch data     Line data    Source code
       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                 :    3121200 :     operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
     325                 :            :     {
     326                 :    3121200 :       complex<_Tp> __r = __x;
     327                 :    3121200 :       __r += __y;
     328                 :    3121200 :       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                 :    2998800 :     operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
     355                 :            :     {
     356                 :    2998800 :       complex<_Tp> __r = __x;
     357                 :    2998800 :       __r -= __y;
     358                 :    2998800 :       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                 :    2539800 :     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
     385                 :            :     {
     386                 :    2539800 :       complex<_Tp> __r = __x;
     387                 :    2539800 :       __r *= __y;
     388                 :    2539800 :       return __r;
     389                 :            :     }
     390                 :            : 
     391                 :            :   template<typename _Tp>
     392                 :            :     inline complex<_Tp>
     393                 :     306000 :     operator*(const complex<_Tp>& __x, const _Tp& __y)
     394                 :            :     {
     395                 :     306000 :       complex<_Tp> __r = __x;
     396                 :     306000 :       __r *= __y;
     397                 :     306000 :       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                 :    1224000 :   __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                 :    1224000 :     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                 :     612000 :         static inline _Tp _S_do_it(const complex<_Tp>& __z)
     651                 :            :         {
     652                 :     612000 :           _Tp __res = std::abs(__z);
     653                 :     612000 :           return __res * __res;
     654                 :            :         }
     655                 :            :     };
     656                 :            :   
     657                 :            :   template<typename _Tp>
     658                 :            :     inline _Tp
     659                 :     612000 :     norm(const complex<_Tp>& __z)
     660                 :            :     {
     661                 :            :       return _Norm_helper<__is_floating<_Tp>::__value 
     662                 :     612000 :         && !_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                 :    1070694 :     conj(const complex<_Tp>& __z)
     673                 :    1070694 :     { 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                 :    1530000 :   __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                 :    1530000 :     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                 :     765000 :       _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
    1199                 :            : 
    1200                 :    6352254 :       _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
    1201                 :            : #if __cplusplus >= 201103L
    1202                 :            :       : _M_value{ __r, __i } { }
    1203                 :            : #else
    1204                 :            :       {
    1205                 :    6352254 :         __real__ _M_value = __r;
    1206                 :    6352254 :         __imag__ _M_value = __i;
    1207                 :    6352254 :       }
    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                 :   12057624 :       real() { return __real__ _M_value; }
    1228                 :            : 
    1229                 :            :       const double& 
    1230                 :   22156236 :       real() const { return __real__ _M_value; }
    1231                 :            : 
    1232                 :            :       double& 
    1233                 :   12057624 :       imag() { return __imag__ _M_value; }
    1234                 :            : 
    1235                 :            :       const double& 
    1236                 :   22153788 :       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                 :          0 :       operator=(double __d)
    1249                 :            :       {
    1250                 :          0 :         _M_value = __d;
    1251                 :          0 :         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                 :     306000 :       operator*=(double __d)
    1270                 :            :       {
    1271                 :     306000 :         _M_value *= __d;
    1272                 :     306000 :         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                 :    4467600 :         operator+=(const complex<_Tp>& __z)
    1297                 :            :         {
    1298                 :    4467600 :           __real__ _M_value += __z.real();
    1299                 :    4467600 :           __imag__ _M_value += __z.imag();
    1300                 :    4467600 :           return *this;
    1301                 :            :         }
    1302                 :            : 
    1303                 :            :       template<typename _Tp>
    1304                 :            :         complex&
    1305                 :    2998800 :         operator-=(const complex<_Tp>& __z)
    1306                 :            :         {
    1307                 :    2998800 :           __real__ _M_value -= __z.real();
    1308                 :    2998800 :           __imag__ _M_value -= __z.imag();
    1309                 :    2998800 :           return *this;
    1310                 :            :         }
    1311                 :            : 
    1312                 :            :       template<typename _Tp>
    1313                 :            :         complex&
    1314                 :    2539800 :         operator*=(const complex<_Tp>& __z)
    1315                 :            :         {
    1316                 :            :           _ComplexT __t;
    1317                 :    2539800 :           __real__ __t = __z.real();
    1318                 :    2539800 :           __imag__ __t = __z.imag();
    1319                 :    2539800 :           _M_value *= __t;
    1320                 :    2539800 :           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                 :    2754000 :       _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 */

Generated by: LCOV version 1.9