Home | History | Annotate | Download | only in v1
      1 // -*- C++ -*-
      2 //===--------------------------- complex ----------------------------------===//
      3 //
      4 //                     The LLVM Compiler Infrastructure
      5 //
      6 // This file is dual licensed under the MIT and the University of Illinois Open
      7 // Source Licenses. See LICENSE.TXT for details.
      8 //
      9 //===----------------------------------------------------------------------===//
     10 
     11 #ifndef _LIBCPP_COMPLEX
     12 #define _LIBCPP_COMPLEX
     13 
     14 /*
     15     complex synopsis
     16 
     17 namespace std
     18 {
     19 
     20 template<class T>
     21 class complex
     22 {
     23 public:
     24     typedef T value_type;
     25 
     26     complex(const T& re = T(), const T& im = T()); // constexpr in C++14
     27     complex(const complex&);  // constexpr in C++14
     28     template<class X> complex(const complex<X>&);  // constexpr in C++14
     29 
     30     T real() const; // constexpr in C++14
     31     T imag() const; // constexpr in C++14
     32 
     33     void real(T);
     34     void imag(T);
     35 
     36     complex<T>& operator= (const T&);
     37     complex<T>& operator+=(const T&);
     38     complex<T>& operator-=(const T&);
     39     complex<T>& operator*=(const T&);
     40     complex<T>& operator/=(const T&);
     41 
     42     complex& operator=(const complex&);
     43     template<class X> complex<T>& operator= (const complex<X>&);
     44     template<class X> complex<T>& operator+=(const complex<X>&);
     45     template<class X> complex<T>& operator-=(const complex<X>&);
     46     template<class X> complex<T>& operator*=(const complex<X>&);
     47     template<class X> complex<T>& operator/=(const complex<X>&);
     48 };
     49 
     50 template<>
     51 class complex<float>
     52 {
     53 public:
     54     typedef float value_type;
     55 
     56     constexpr complex(float re = 0.0f, float im = 0.0f);
     57     explicit constexpr complex(const complex<double>&);
     58     explicit constexpr complex(const complex<long double>&);
     59 
     60     constexpr float real() const;
     61     void real(float);
     62     constexpr float imag() const;
     63     void imag(float);
     64 
     65     complex<float>& operator= (float);
     66     complex<float>& operator+=(float);
     67     complex<float>& operator-=(float);
     68     complex<float>& operator*=(float);
     69     complex<float>& operator/=(float);
     70 
     71     complex<float>& operator=(const complex<float>&);
     72     template<class X> complex<float>& operator= (const complex<X>&);
     73     template<class X> complex<float>& operator+=(const complex<X>&);
     74     template<class X> complex<float>& operator-=(const complex<X>&);
     75     template<class X> complex<float>& operator*=(const complex<X>&);
     76     template<class X> complex<float>& operator/=(const complex<X>&);
     77 };
     78 
     79 template<>
     80 class complex<double>
     81 {
     82 public:
     83     typedef double value_type;
     84 
     85     constexpr complex(double re = 0.0, double im = 0.0);
     86     constexpr complex(const complex<float>&);
     87     explicit constexpr complex(const complex<long double>&);
     88 
     89     constexpr double real() const;
     90     void real(double);
     91     constexpr double imag() const;
     92     void imag(double);
     93 
     94     complex<double>& operator= (double);
     95     complex<double>& operator+=(double);
     96     complex<double>& operator-=(double);
     97     complex<double>& operator*=(double);
     98     complex<double>& operator/=(double);
     99     complex<double>& operator=(const complex<double>&);
    100 
    101     template<class X> complex<double>& operator= (const complex<X>&);
    102     template<class X> complex<double>& operator+=(const complex<X>&);
    103     template<class X> complex<double>& operator-=(const complex<X>&);
    104     template<class X> complex<double>& operator*=(const complex<X>&);
    105     template<class X> complex<double>& operator/=(const complex<X>&);
    106 };
    107 
    108 template<>
    109 class complex<long double>
    110 {
    111 public:
    112     typedef long double value_type;
    113 
    114     constexpr complex(long double re = 0.0L, long double im = 0.0L);
    115     constexpr complex(const complex<float>&);
    116     constexpr complex(const complex<double>&);
    117 
    118     constexpr long double real() const;
    119     void real(long double);
    120     constexpr long double imag() const;
    121     void imag(long double);
    122 
    123     complex<long double>& operator=(const complex<long double>&);
    124     complex<long double>& operator= (long double);
    125     complex<long double>& operator+=(long double);
    126     complex<long double>& operator-=(long double);
    127     complex<long double>& operator*=(long double);
    128     complex<long double>& operator/=(long double);
    129 
    130     template<class X> complex<long double>& operator= (const complex<X>&);
    131     template<class X> complex<long double>& operator+=(const complex<X>&);
    132     template<class X> complex<long double>& operator-=(const complex<X>&);
    133     template<class X> complex<long double>& operator*=(const complex<X>&);
    134     template<class X> complex<long double>& operator/=(const complex<X>&);
    135 };
    136 
    137 // 26.3.6 operators:
    138 template<class T> complex<T> operator+(const complex<T>&, const complex<T>&);
    139 template<class T> complex<T> operator+(const complex<T>&, const T&);
    140 template<class T> complex<T> operator+(const T&, const complex<T>&);
    141 template<class T> complex<T> operator-(const complex<T>&, const complex<T>&);
    142 template<class T> complex<T> operator-(const complex<T>&, const T&);
    143 template<class T> complex<T> operator-(const T&, const complex<T>&);
    144 template<class T> complex<T> operator*(const complex<T>&, const complex<T>&);
    145 template<class T> complex<T> operator*(const complex<T>&, const T&);
    146 template<class T> complex<T> operator*(const T&, const complex<T>&);
    147 template<class T> complex<T> operator/(const complex<T>&, const complex<T>&);
    148 template<class T> complex<T> operator/(const complex<T>&, const T&);
    149 template<class T> complex<T> operator/(const T&, const complex<T>&);
    150 template<class T> complex<T> operator+(const complex<T>&);
    151 template<class T> complex<T> operator-(const complex<T>&);
    152 template<class T> bool operator==(const complex<T>&, const complex<T>&); // constexpr in C++14
    153 template<class T> bool operator==(const complex<T>&, const T&); // constexpr in C++14
    154 template<class T> bool operator==(const T&, const complex<T>&); // constexpr in C++14
    155 template<class T> bool operator!=(const complex<T>&, const complex<T>&); // constexpr in C++14
    156 template<class T> bool operator!=(const complex<T>&, const T&); // constexpr in C++14
    157 template<class T> bool operator!=(const T&, const complex<T>&); // constexpr in C++14
    158 
    159 template<class T, class charT, class traits>
    160   basic_istream<charT, traits>&
    161   operator>>(basic_istream<charT, traits>&, complex<T>&);
    162 template<class T, class charT, class traits>
    163   basic_ostream<charT, traits>&
    164   operator<<(basic_ostream<charT, traits>&, const complex<T>&);
    165 
    166 // 26.3.7 values:
    167 
    168 template<class T>              T real(const complex<T>&); // constexpr in C++14
    169                      long double real(long double);       // constexpr in C++14
    170                           double real(double);            // constexpr in C++14
    171 template<Integral T>      double real(T);                 // constexpr in C++14
    172                           float  real(float);             // constexpr in C++14
    173 
    174 template<class T>              T imag(const complex<T>&); // constexpr in C++14
    175                      long double imag(long double);       // constexpr in C++14
    176                           double imag(double);            // constexpr in C++14
    177 template<Integral T>      double imag(T);                 // constexpr in C++14
    178                           float  imag(float);             // constexpr in C++14
    179 
    180 template<class T> T abs(const complex<T>&);
    181 
    182 template<class T>              T arg(const complex<T>&);
    183                      long double arg(long double);
    184                           double arg(double);
    185 template<Integral T>      double arg(T);
    186                           float  arg(float);
    187 
    188 template<class T>              T norm(const complex<T>&);
    189                      long double norm(long double);
    190                           double norm(double);
    191 template<Integral T>      double norm(T);
    192                           float  norm(float);
    193 
    194 template<class T>      complex<T>           conj(const complex<T>&);
    195                        complex<long double> conj(long double);
    196                        complex<double>      conj(double);
    197 template<Integral T>   complex<double>      conj(T);
    198                        complex<float>       conj(float);
    199 
    200 template<class T>    complex<T>           proj(const complex<T>&);
    201                      complex<long double> proj(long double);
    202                      complex<double>      proj(double);
    203 template<Integral T> complex<double>      proj(T);
    204                      complex<float>       proj(float);
    205 
    206 template<class T> complex<T> polar(const T&, const T& = 0);
    207 
    208 // 26.3.8 transcendentals:
    209 template<class T> complex<T> acos(const complex<T>&);
    210 template<class T> complex<T> asin(const complex<T>&);
    211 template<class T> complex<T> atan(const complex<T>&);
    212 template<class T> complex<T> acosh(const complex<T>&);
    213 template<class T> complex<T> asinh(const complex<T>&);
    214 template<class T> complex<T> atanh(const complex<T>&);
    215 template<class T> complex<T> cos (const complex<T>&);
    216 template<class T> complex<T> cosh (const complex<T>&);
    217 template<class T> complex<T> exp (const complex<T>&);
    218 template<class T> complex<T> log (const complex<T>&);
    219 template<class T> complex<T> log10(const complex<T>&);
    220 
    221 template<class T> complex<T> pow(const complex<T>&, const T&);
    222 template<class T> complex<T> pow(const complex<T>&, const complex<T>&);
    223 template<class T> complex<T> pow(const T&, const complex<T>&);
    224 
    225 template<class T> complex<T> sin (const complex<T>&);
    226 template<class T> complex<T> sinh (const complex<T>&);
    227 template<class T> complex<T> sqrt (const complex<T>&);
    228 template<class T> complex<T> tan (const complex<T>&);
    229 template<class T> complex<T> tanh (const complex<T>&);
    230 
    231 template<class T, class charT, class traits>
    232   basic_istream<charT, traits>&
    233   operator>>(basic_istream<charT, traits>& is, complex<T>& x);
    234 
    235 template<class T, class charT, class traits>
    236   basic_ostream<charT, traits>&
    237   operator<<(basic_ostream<charT, traits>& o, const complex<T>& x);
    238 
    239 }  // std
    240 
    241 */
    242 
    243 #include <__config>
    244 #include <type_traits>
    245 #include <stdexcept>
    246 #include <cmath>
    247 #include <sstream>
    248 
    249 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
    250 #pragma GCC system_header
    251 #endif
    252 
    253 _LIBCPP_BEGIN_NAMESPACE_STD
    254 
    255 template<class _Tp> class _LIBCPP_TEMPLATE_VIS complex;
    256 
    257 template<class _Tp> complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
    258 template<class _Tp> complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
    259 
    260 template<class _Tp>
    261 class _LIBCPP_TEMPLATE_VIS complex
    262 {
    263 public:
    264     typedef _Tp value_type;
    265 private:
    266     value_type __re_;
    267     value_type __im_;
    268 public:
    269     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    270     complex(const value_type& __re = value_type(), const value_type& __im = value_type())
    271         : __re_(__re), __im_(__im) {}
    272     template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    273     complex(const complex<_Xp>& __c)
    274         : __re_(__c.real()), __im_(__c.imag()) {}
    275 
    276     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 value_type real() const {return __re_;}
    277     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 value_type imag() const {return __im_;}
    278 
    279     _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
    280     _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
    281 
    282     _LIBCPP_INLINE_VISIBILITY complex& operator= (const value_type& __re)
    283         {__re_ = __re; __im_ = value_type(); return *this;}
    284     _LIBCPP_INLINE_VISIBILITY complex& operator+=(const value_type& __re) {__re_ += __re; return *this;}
    285     _LIBCPP_INLINE_VISIBILITY complex& operator-=(const value_type& __re) {__re_ -= __re; return *this;}
    286     _LIBCPP_INLINE_VISIBILITY complex& operator*=(const value_type& __re) {__re_ *= __re; __im_ *= __re; return *this;}
    287     _LIBCPP_INLINE_VISIBILITY complex& operator/=(const value_type& __re) {__re_ /= __re; __im_ /= __re; return *this;}
    288 
    289     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
    290         {
    291             __re_ = __c.real();
    292             __im_ = __c.imag();
    293             return *this;
    294         }
    295     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
    296         {
    297             __re_ += __c.real();
    298             __im_ += __c.imag();
    299             return *this;
    300         }
    301     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
    302         {
    303             __re_ -= __c.real();
    304             __im_ -= __c.imag();
    305             return *this;
    306         }
    307     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
    308         {
    309             *this = *this * complex(__c.real(), __c.imag());
    310             return *this;
    311         }
    312     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
    313         {
    314             *this = *this / complex(__c.real(), __c.imag());
    315             return *this;
    316         }
    317 };
    318 
    319 template<> class _LIBCPP_TEMPLATE_VIS complex<double>;
    320 template<> class _LIBCPP_TEMPLATE_VIS complex<long double>;
    321 
    322 template<>
    323 class _LIBCPP_TEMPLATE_VIS complex<float>
    324 {
    325     float __re_;
    326     float __im_;
    327 public:
    328     typedef float value_type;
    329 
    330     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(float __re = 0.0f, float __im = 0.0f)
    331         : __re_(__re), __im_(__im) {}
    332     _LIBCPP_INLINE_VISIBILITY
    333     explicit _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
    334     _LIBCPP_INLINE_VISIBILITY
    335     explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
    336 
    337     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float real() const {return __re_;}
    338     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float imag() const {return __im_;}
    339 
    340     _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
    341     _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
    342 
    343     _LIBCPP_INLINE_VISIBILITY complex& operator= (float __re)
    344         {__re_ = __re; __im_ = value_type(); return *this;}
    345     _LIBCPP_INLINE_VISIBILITY complex& operator+=(float __re) {__re_ += __re; return *this;}
    346     _LIBCPP_INLINE_VISIBILITY complex& operator-=(float __re) {__re_ -= __re; return *this;}
    347     _LIBCPP_INLINE_VISIBILITY complex& operator*=(float __re) {__re_ *= __re; __im_ *= __re; return *this;}
    348     _LIBCPP_INLINE_VISIBILITY complex& operator/=(float __re) {__re_ /= __re; __im_ /= __re; return *this;}
    349 
    350     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
    351         {
    352             __re_ = __c.real();
    353             __im_ = __c.imag();
    354             return *this;
    355         }
    356     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
    357         {
    358             __re_ += __c.real();
    359             __im_ += __c.imag();
    360             return *this;
    361         }
    362     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
    363         {
    364             __re_ -= __c.real();
    365             __im_ -= __c.imag();
    366             return *this;
    367         }
    368     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
    369         {
    370             *this = *this * complex(__c.real(), __c.imag());
    371             return *this;
    372         }
    373     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
    374         {
    375             *this = *this / complex(__c.real(), __c.imag());
    376             return *this;
    377         }
    378 };
    379 
    380 template<>
    381 class _LIBCPP_TEMPLATE_VIS complex<double>
    382 {
    383     double __re_;
    384     double __im_;
    385 public:
    386     typedef double value_type;
    387 
    388     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(double __re = 0.0, double __im = 0.0)
    389         : __re_(__re), __im_(__im) {}
    390     _LIBCPP_INLINE_VISIBILITY
    391     _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
    392     _LIBCPP_INLINE_VISIBILITY
    393     explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
    394 
    395     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double real() const {return __re_;}
    396     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double imag() const {return __im_;}
    397 
    398     _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
    399     _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
    400 
    401     _LIBCPP_INLINE_VISIBILITY complex& operator= (double __re)
    402         {__re_ = __re; __im_ = value_type(); return *this;}
    403     _LIBCPP_INLINE_VISIBILITY complex& operator+=(double __re) {__re_ += __re; return *this;}
    404     _LIBCPP_INLINE_VISIBILITY complex& operator-=(double __re) {__re_ -= __re; return *this;}
    405     _LIBCPP_INLINE_VISIBILITY complex& operator*=(double __re) {__re_ *= __re; __im_ *= __re; return *this;}
    406     _LIBCPP_INLINE_VISIBILITY complex& operator/=(double __re) {__re_ /= __re; __im_ /= __re; return *this;}
    407 
    408     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
    409         {
    410             __re_ = __c.real();
    411             __im_ = __c.imag();
    412             return *this;
    413         }
    414     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
    415         {
    416             __re_ += __c.real();
    417             __im_ += __c.imag();
    418             return *this;
    419         }
    420     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
    421         {
    422             __re_ -= __c.real();
    423             __im_ -= __c.imag();
    424             return *this;
    425         }
    426     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
    427         {
    428             *this = *this * complex(__c.real(), __c.imag());
    429             return *this;
    430         }
    431     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
    432         {
    433             *this = *this / complex(__c.real(), __c.imag());
    434             return *this;
    435         }
    436 };
    437 
    438 template<>
    439 class _LIBCPP_TEMPLATE_VIS complex<long double>
    440 {
    441     long double __re_;
    442     long double __im_;
    443 public:
    444     typedef long double value_type;
    445 
    446     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(long double __re = 0.0L, long double __im = 0.0L)
    447         : __re_(__re), __im_(__im) {}
    448     _LIBCPP_INLINE_VISIBILITY
    449     _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
    450     _LIBCPP_INLINE_VISIBILITY
    451     _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
    452 
    453     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double real() const {return __re_;}
    454     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double imag() const {return __im_;}
    455 
    456     _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
    457     _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
    458 
    459     _LIBCPP_INLINE_VISIBILITY complex& operator= (long double __re)
    460         {__re_ = __re; __im_ = value_type(); return *this;}
    461     _LIBCPP_INLINE_VISIBILITY complex& operator+=(long double __re) {__re_ += __re; return *this;}
    462     _LIBCPP_INLINE_VISIBILITY complex& operator-=(long double __re) {__re_ -= __re; return *this;}
    463     _LIBCPP_INLINE_VISIBILITY complex& operator*=(long double __re) {__re_ *= __re; __im_ *= __re; return *this;}
    464     _LIBCPP_INLINE_VISIBILITY complex& operator/=(long double __re) {__re_ /= __re; __im_ /= __re; return *this;}
    465 
    466     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
    467         {
    468             __re_ = __c.real();
    469             __im_ = __c.imag();
    470             return *this;
    471         }
    472     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
    473         {
    474             __re_ += __c.real();
    475             __im_ += __c.imag();
    476             return *this;
    477         }
    478     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
    479         {
    480             __re_ -= __c.real();
    481             __im_ -= __c.imag();
    482             return *this;
    483         }
    484     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
    485         {
    486             *this = *this * complex(__c.real(), __c.imag());
    487             return *this;
    488         }
    489     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
    490         {
    491             *this = *this / complex(__c.real(), __c.imag());
    492             return *this;
    493         }
    494 };
    495 
    496 inline
    497 _LIBCPP_CONSTEXPR
    498 complex<float>::complex(const complex<double>& __c)
    499     : __re_(__c.real()), __im_(__c.imag()) {}
    500 
    501 inline
    502 _LIBCPP_CONSTEXPR
    503 complex<float>::complex(const complex<long double>& __c)
    504     : __re_(__c.real()), __im_(__c.imag()) {}
    505 
    506 inline
    507 _LIBCPP_CONSTEXPR
    508 complex<double>::complex(const complex<float>& __c)
    509     : __re_(__c.real()), __im_(__c.imag()) {}
    510 
    511 inline
    512 _LIBCPP_CONSTEXPR
    513 complex<double>::complex(const complex<long double>& __c)
    514     : __re_(__c.real()), __im_(__c.imag()) {}
    515 
    516 inline
    517 _LIBCPP_CONSTEXPR
    518 complex<long double>::complex(const complex<float>& __c)
    519     : __re_(__c.real()), __im_(__c.imag()) {}
    520 
    521 inline
    522 _LIBCPP_CONSTEXPR
    523 complex<long double>::complex(const complex<double>& __c)
    524     : __re_(__c.real()), __im_(__c.imag()) {}
    525 
    526 // 26.3.6 operators:
    527 
    528 template<class _Tp>
    529 inline _LIBCPP_INLINE_VISIBILITY
    530 complex<_Tp>
    531 operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
    532 {
    533     complex<_Tp> __t(__x);
    534     __t += __y;
    535     return __t;
    536 }
    537 
    538 template<class _Tp>
    539 inline _LIBCPP_INLINE_VISIBILITY
    540 complex<_Tp>
    541 operator+(const complex<_Tp>& __x, const _Tp& __y)
    542 {
    543     complex<_Tp> __t(__x);
    544     __t += __y;
    545     return __t;
    546 }
    547 
    548 template<class _Tp>
    549 inline _LIBCPP_INLINE_VISIBILITY
    550 complex<_Tp>
    551 operator+(const _Tp& __x, const complex<_Tp>& __y)
    552 {
    553     complex<_Tp> __t(__y);
    554     __t += __x;
    555     return __t;
    556 }
    557 
    558 template<class _Tp>
    559 inline _LIBCPP_INLINE_VISIBILITY
    560 complex<_Tp>
    561 operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
    562 {
    563     complex<_Tp> __t(__x);
    564     __t -= __y;
    565     return __t;
    566 }
    567 
    568 template<class _Tp>
    569 inline _LIBCPP_INLINE_VISIBILITY
    570 complex<_Tp>
    571 operator-(const complex<_Tp>& __x, const _Tp& __y)
    572 {
    573     complex<_Tp> __t(__x);
    574     __t -= __y;
    575     return __t;
    576 }
    577 
    578 template<class _Tp>
    579 inline _LIBCPP_INLINE_VISIBILITY
    580 complex<_Tp>
    581 operator-(const _Tp& __x, const complex<_Tp>& __y)
    582 {
    583     complex<_Tp> __t(-__y);
    584     __t += __x;
    585     return __t;
    586 }
    587 
    588 template<class _Tp>
    589 complex<_Tp>
    590 operator*(const complex<_Tp>& __z, const complex<_Tp>& __w)
    591 {
    592     _Tp __a = __z.real();
    593     _Tp __b = __z.imag();
    594     _Tp __c = __w.real();
    595     _Tp __d = __w.imag();
    596     _Tp __ac = __a * __c;
    597     _Tp __bd = __b * __d;
    598     _Tp __ad = __a * __d;
    599     _Tp __bc = __b * __c;
    600     _Tp __x = __ac - __bd;
    601     _Tp __y = __ad + __bc;
    602     if (__libcpp_isnan(__x) && __libcpp_isnan(__y))
    603     {
    604         bool __recalc = false;
    605         if (__libcpp_isinf(__a) || __libcpp_isinf(__b))
    606         {
    607             __a = copysign(__libcpp_isinf(__a) ? _Tp(1) : _Tp(0), __a);
    608             __b = copysign(__libcpp_isinf(__b) ? _Tp(1) : _Tp(0), __b);
    609             if (__libcpp_isnan(__c))
    610                 __c = copysign(_Tp(0), __c);
    611             if (__libcpp_isnan(__d))
    612                 __d = copysign(_Tp(0), __d);
    613             __recalc = true;
    614         }
    615         if (__libcpp_isinf(__c) || __libcpp_isinf(__d))
    616         {
    617             __c = copysign(__libcpp_isinf(__c) ? _Tp(1) : _Tp(0), __c);
    618             __d = copysign(__libcpp_isinf(__d) ? _Tp(1) : _Tp(0), __d);
    619             if (__libcpp_isnan(__a))
    620                 __a = copysign(_Tp(0), __a);
    621             if (__libcpp_isnan(__b))
    622                 __b = copysign(_Tp(0), __b);
    623             __recalc = true;
    624         }
    625         if (!__recalc && (__libcpp_isinf(__ac) || __libcpp_isinf(__bd) ||
    626                           __libcpp_isinf(__ad) || __libcpp_isinf(__bc)))
    627         {
    628             if (__libcpp_isnan(__a))
    629                 __a = copysign(_Tp(0), __a);
    630             if (__libcpp_isnan(__b))
    631                 __b = copysign(_Tp(0), __b);
    632             if (__libcpp_isnan(__c))
    633                 __c = copysign(_Tp(0), __c);
    634             if (__libcpp_isnan(__d))
    635                 __d = copysign(_Tp(0), __d);
    636             __recalc = true;
    637         }
    638         if (__recalc)
    639         {
    640             __x = _Tp(INFINITY) * (__a * __c - __b * __d);
    641             __y = _Tp(INFINITY) * (__a * __d + __b * __c);
    642         }
    643     }
    644     return complex<_Tp>(__x, __y);
    645 }
    646 
    647 template<class _Tp>
    648 inline _LIBCPP_INLINE_VISIBILITY
    649 complex<_Tp>
    650 operator*(const complex<_Tp>& __x, const _Tp& __y)
    651 {
    652     complex<_Tp> __t(__x);
    653     __t *= __y;
    654     return __t;
    655 }
    656 
    657 template<class _Tp>
    658 inline _LIBCPP_INLINE_VISIBILITY
    659 complex<_Tp>
    660 operator*(const _Tp& __x, const complex<_Tp>& __y)
    661 {
    662     complex<_Tp> __t(__y);
    663     __t *= __x;
    664     return __t;
    665 }
    666 
    667 template<class _Tp>
    668 complex<_Tp>
    669 operator/(const complex<_Tp>& __z, const complex<_Tp>& __w)
    670 {
    671     int __ilogbw = 0;
    672     _Tp __a = __z.real();
    673     _Tp __b = __z.imag();
    674     _Tp __c = __w.real();
    675     _Tp __d = __w.imag();
    676     _Tp __logbw = logb(fmax(fabs(__c), fabs(__d)));
    677     if (__libcpp_isfinite(__logbw))
    678     {
    679         __ilogbw = static_cast<int>(__logbw);
    680         __c = scalbn(__c, -__ilogbw);
    681         __d = scalbn(__d, -__ilogbw);
    682     }
    683     _Tp __denom = __c * __c + __d * __d;
    684     _Tp __x = scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
    685     _Tp __y = scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
    686     if (__libcpp_isnan(__x) && __libcpp_isnan(__y))
    687     {
    688         if ((__denom == _Tp(0)) && (!__libcpp_isnan(__a) || !__libcpp_isnan(__b)))
    689         {
    690             __x = copysign(_Tp(INFINITY), __c) * __a;
    691             __y = copysign(_Tp(INFINITY), __c) * __b;
    692         }
    693         else if ((__libcpp_isinf(__a) || __libcpp_isinf(__b)) && __libcpp_isfinite(__c) && __libcpp_isfinite(__d))
    694         {
    695             __a = copysign(__libcpp_isinf(__a) ? _Tp(1) : _Tp(0), __a);
    696             __b = copysign(__libcpp_isinf(__b) ? _Tp(1) : _Tp(0), __b);
    697             __x = _Tp(INFINITY) * (__a * __c + __b * __d);
    698             __y = _Tp(INFINITY) * (__b * __c - __a * __d);
    699         }
    700         else if (__libcpp_isinf(__logbw) && __logbw > _Tp(0) && __libcpp_isfinite(__a) && __libcpp_isfinite(__b))
    701         {
    702             __c = copysign(__libcpp_isinf(__c) ? _Tp(1) : _Tp(0), __c);
    703             __d = copysign(__libcpp_isinf(__d) ? _Tp(1) : _Tp(0), __d);
    704             __x = _Tp(0) * (__a * __c + __b * __d);
    705             __y = _Tp(0) * (__b * __c - __a * __d);
    706         }
    707     }
    708     return complex<_Tp>(__x, __y);
    709 }
    710 
    711 template<class _Tp>
    712 inline _LIBCPP_INLINE_VISIBILITY
    713 complex<_Tp>
    714 operator/(const complex<_Tp>& __x, const _Tp& __y)
    715 {
    716     return complex<_Tp>(__x.real() / __y, __x.imag() / __y);
    717 }
    718 
    719 template<class _Tp>
    720 inline _LIBCPP_INLINE_VISIBILITY
    721 complex<_Tp>
    722 operator/(const _Tp& __x, const complex<_Tp>& __y)
    723 {
    724     complex<_Tp> __t(__x);
    725     __t /= __y;
    726     return __t;
    727 }
    728 
    729 template<class _Tp>
    730 inline _LIBCPP_INLINE_VISIBILITY
    731 complex<_Tp>
    732 operator+(const complex<_Tp>& __x)
    733 {
    734     return __x;
    735 }
    736 
    737 template<class _Tp>
    738 inline _LIBCPP_INLINE_VISIBILITY
    739 complex<_Tp>
    740 operator-(const complex<_Tp>& __x)
    741 {
    742     return complex<_Tp>(-__x.real(), -__x.imag());
    743 }
    744 
    745 template<class _Tp>
    746 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    747 bool
    748 operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
    749 {
    750     return __x.real() == __y.real() && __x.imag() == __y.imag();
    751 }
    752 
    753 template<class _Tp>
    754 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    755 bool
    756 operator==(const complex<_Tp>& __x, const _Tp& __y)
    757 {
    758     return __x.real() == __y && __x.imag() == 0;
    759 }
    760 
    761 template<class _Tp>
    762 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    763 bool
    764 operator==(const _Tp& __x, const complex<_Tp>& __y)
    765 {
    766     return __x == __y.real() && 0 == __y.imag();
    767 }
    768 
    769 template<class _Tp>
    770 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    771 bool
    772 operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
    773 {
    774     return !(__x == __y);
    775 }
    776 
    777 template<class _Tp>
    778 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    779 bool
    780 operator!=(const complex<_Tp>& __x, const _Tp& __y)
    781 {
    782     return !(__x == __y);
    783 }
    784 
    785 template<class _Tp>
    786 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    787 bool
    788 operator!=(const _Tp& __x, const complex<_Tp>& __y)
    789 {
    790     return !(__x == __y);
    791 }
    792 
    793 // 26.3.7 values:
    794 
    795 template <class _Tp, bool = is_integral<_Tp>::value,
    796                      bool = is_floating_point<_Tp>::value
    797                      >
    798 struct __libcpp_complex_overload_traits {};
    799 
    800 // Integral Types
    801 template <class _Tp>
    802 struct __libcpp_complex_overload_traits<_Tp, true, false>
    803 {
    804     typedef double _ValueType;
    805     typedef complex<double> _ComplexType;
    806 };
    807 
    808 // Floating point types
    809 template <class _Tp>
    810 struct __libcpp_complex_overload_traits<_Tp, false, true>
    811 {
    812     typedef _Tp _ValueType;
    813     typedef complex<_Tp> _ComplexType;
    814 };
    815 
    816 // real
    817 
    818 template<class _Tp>
    819 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    820 _Tp
    821 real(const complex<_Tp>& __c)
    822 {
    823     return __c.real();
    824 }
    825 
    826 template <class _Tp>
    827 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    828 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
    829 real(_Tp __re)
    830 {
    831     return __re;
    832 }
    833 
    834 // imag
    835 
    836 template<class _Tp>
    837 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    838 _Tp
    839 imag(const complex<_Tp>& __c)
    840 {
    841     return __c.imag();
    842 }
    843 
    844 template <class _Tp>
    845 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
    846 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
    847 imag(_Tp)
    848 {
    849     return 0;
    850 }
    851 
    852 // abs
    853 
    854 template<class _Tp>
    855 inline _LIBCPP_INLINE_VISIBILITY
    856 _Tp
    857 abs(const complex<_Tp>& __c)
    858 {
    859     return hypot(__c.real(), __c.imag());
    860 }
    861 
    862 // arg
    863 
    864 template<class _Tp>
    865 inline _LIBCPP_INLINE_VISIBILITY
    866 _Tp
    867 arg(const complex<_Tp>& __c)
    868 {
    869     return atan2(__c.imag(), __c.real());
    870 }
    871 
    872 template <class _Tp>
    873 inline _LIBCPP_INLINE_VISIBILITY
    874 typename enable_if<
    875     is_same<_Tp, long double>::value,
    876     long double
    877 >::type
    878 arg(_Tp __re)
    879 {
    880     return atan2l(0.L, __re);
    881 }
    882 
    883 template<class _Tp>
    884 inline _LIBCPP_INLINE_VISIBILITY
    885 typename enable_if
    886 <
    887     is_integral<_Tp>::value || is_same<_Tp, double>::value,
    888     double
    889 >::type
    890 arg(_Tp __re)
    891 {
    892     return atan2(0., __re);
    893 }
    894 
    895 template <class _Tp>
    896 inline _LIBCPP_INLINE_VISIBILITY
    897 typename enable_if<
    898     is_same<_Tp, float>::value,
    899     float
    900 >::type
    901 arg(_Tp __re)
    902 {
    903     return atan2f(0.F, __re);
    904 }
    905 
    906 // norm
    907 
    908 template<class _Tp>
    909 inline _LIBCPP_INLINE_VISIBILITY
    910 _Tp
    911 norm(const complex<_Tp>& __c)
    912 {
    913     if (__libcpp_isinf(__c.real()))
    914         return abs(__c.real());
    915     if (__libcpp_isinf(__c.imag()))
    916         return abs(__c.imag());
    917     return __c.real() * __c.real() + __c.imag() * __c.imag();
    918 }
    919 
    920 template <class _Tp>
    921 inline _LIBCPP_INLINE_VISIBILITY
    922 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
    923 norm(_Tp __re)
    924 {
    925     typedef typename __libcpp_complex_overload_traits<_Tp>::_ValueType _ValueType;
    926     return static_cast<_ValueType>(__re) * __re;
    927 }
    928 
    929 // conj
    930 
    931 template<class _Tp>
    932 inline _LIBCPP_INLINE_VISIBILITY
    933 complex<_Tp>
    934 conj(const complex<_Tp>& __c)
    935 {
    936     return complex<_Tp>(__c.real(), -__c.imag());
    937 }
    938 
    939 template <class _Tp>
    940 inline _LIBCPP_INLINE_VISIBILITY
    941 typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
    942 conj(_Tp __re)
    943 {
    944     typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
    945     return _ComplexType(__re);
    946 }
    947 
    948 
    949 
    950 // proj
    951 
    952 template<class _Tp>
    953 inline _LIBCPP_INLINE_VISIBILITY
    954 complex<_Tp>
    955 proj(const complex<_Tp>& __c)
    956 {
    957     std::complex<_Tp> __r = __c;
    958     if (__libcpp_isinf(__c.real()) || __libcpp_isinf(__c.imag()))
    959         __r = complex<_Tp>(INFINITY, copysign(_Tp(0), __c.imag()));
    960     return __r;
    961 }
    962 
    963 template <class _Tp>
    964 inline _LIBCPP_INLINE_VISIBILITY
    965 typename enable_if
    966 <
    967     is_floating_point<_Tp>::value,
    968     typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
    969 >::type
    970 proj(_Tp __re)
    971 {
    972     if (__libcpp_isinf(__re))
    973         __re = abs(__re);
    974     return complex<_Tp>(__re);
    975 }
    976 
    977 template <class _Tp>
    978 inline _LIBCPP_INLINE_VISIBILITY
    979 typename enable_if
    980 <
    981     is_integral<_Tp>::value,
    982     typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
    983 >::type
    984 proj(_Tp __re)
    985 {
    986     typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
    987     return _ComplexType(__re);
    988 }
    989 
    990 // polar
    991 
    992 template<class _Tp>
    993 complex<_Tp>
    994 polar(const _Tp& __rho, const _Tp& __theta = _Tp(0))
    995 {
    996     if (__libcpp_isnan(__rho) || signbit(__rho))
    997         return complex<_Tp>(_Tp(NAN), _Tp(NAN));
    998     if (__libcpp_isnan(__theta))
    999     {
   1000         if (__libcpp_isinf(__rho))
   1001             return complex<_Tp>(__rho, __theta);
   1002         return complex<_Tp>(__theta, __theta);
   1003     }
   1004     if (__libcpp_isinf(__theta))
   1005     {
   1006         if (__libcpp_isinf(__rho))
   1007             return complex<_Tp>(__rho, _Tp(NAN));
   1008         return complex<_Tp>(_Tp(NAN), _Tp(NAN));
   1009     }
   1010     _Tp __x = __rho * cos(__theta);
   1011     if (__libcpp_isnan(__x))
   1012         __x = 0;
   1013     _Tp __y = __rho * sin(__theta);
   1014     if (__libcpp_isnan(__y))
   1015         __y = 0;
   1016     return complex<_Tp>(__x, __y);
   1017 }
   1018 
   1019 // log
   1020 
   1021 template<class _Tp>
   1022 inline _LIBCPP_INLINE_VISIBILITY
   1023 complex<_Tp>
   1024 log(const complex<_Tp>& __x)
   1025 {
   1026     return complex<_Tp>(log(abs(__x)), arg(__x));
   1027 }
   1028 
   1029 // log10
   1030 
   1031 template<class _Tp>
   1032 inline _LIBCPP_INLINE_VISIBILITY
   1033 complex<_Tp>
   1034 log10(const complex<_Tp>& __x)
   1035 {
   1036     return log(__x) / log(_Tp(10));
   1037 }
   1038 
   1039 // sqrt
   1040 
   1041 template<class _Tp>
   1042 complex<_Tp>
   1043 sqrt(const complex<_Tp>& __x)
   1044 {
   1045     if (__libcpp_isinf(__x.imag()))
   1046         return complex<_Tp>(_Tp(INFINITY), __x.imag());
   1047     if (__libcpp_isinf(__x.real()))
   1048     {
   1049         if (__x.real() > _Tp(0))
   1050             return complex<_Tp>(__x.real(), __libcpp_isnan(__x.imag()) ? __x.imag() : copysign(_Tp(0), __x.imag()));
   1051         return complex<_Tp>(__libcpp_isnan(__x.imag()) ? __x.imag() : _Tp(0), copysign(__x.real(), __x.imag()));
   1052     }
   1053     return polar(sqrt(abs(__x)), arg(__x) / _Tp(2));
   1054 }
   1055 
   1056 // exp
   1057 
   1058 template<class _Tp>
   1059 complex<_Tp>
   1060 exp(const complex<_Tp>& __x)
   1061 {
   1062     _Tp __i = __x.imag();
   1063     if (__libcpp_isinf(__x.real()))
   1064     {
   1065         if (__x.real() < _Tp(0))
   1066         {
   1067             if (!__libcpp_isfinite(__i))
   1068                 __i = _Tp(1);
   1069         }
   1070         else if (__i == 0 || !__libcpp_isfinite(__i))
   1071         {
   1072             if (__libcpp_isinf(__i))
   1073                 __i = _Tp(NAN);
   1074             return complex<_Tp>(__x.real(), __i);
   1075         }
   1076     }
   1077     else if (__libcpp_isnan(__x.real()) && __x.imag() == 0)
   1078         return __x;
   1079     _Tp __e = exp(__x.real());
   1080     return complex<_Tp>(__e * cos(__i), __e * sin(__i));
   1081 }
   1082 
   1083 // pow
   1084 
   1085 template<class _Tp>
   1086 inline _LIBCPP_INLINE_VISIBILITY
   1087 complex<_Tp>
   1088 pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
   1089 {
   1090     return exp(__y * log(__x));
   1091 }
   1092 
   1093 template<class _Tp, class _Up>
   1094 inline _LIBCPP_INLINE_VISIBILITY
   1095 complex<typename __promote<_Tp, _Up>::type>
   1096 pow(const complex<_Tp>& __x, const complex<_Up>& __y)
   1097 {
   1098     typedef complex<typename __promote<_Tp, _Up>::type> result_type;
   1099     return _VSTD::pow(result_type(__x), result_type(__y));
   1100 }
   1101 
   1102 template<class _Tp, class _Up>
   1103 inline _LIBCPP_INLINE_VISIBILITY
   1104 typename enable_if
   1105 <
   1106     is_arithmetic<_Up>::value,
   1107     complex<typename __promote<_Tp, _Up>::type>
   1108 >::type
   1109 pow(const complex<_Tp>& __x, const _Up& __y)
   1110 {
   1111     typedef complex<typename __promote<_Tp, _Up>::type> result_type;
   1112     return _VSTD::pow(result_type(__x), result_type(__y));
   1113 }
   1114 
   1115 template<class _Tp, class _Up>
   1116 inline _LIBCPP_INLINE_VISIBILITY
   1117 typename enable_if
   1118 <
   1119     is_arithmetic<_Tp>::value,
   1120     complex<typename __promote<_Tp, _Up>::type>
   1121 >::type
   1122 pow(const _Tp& __x, const complex<_Up>& __y)
   1123 {
   1124     typedef complex<typename __promote<_Tp, _Up>::type> result_type;
   1125     return _VSTD::pow(result_type(__x), result_type(__y));
   1126 }
   1127 
   1128 // asinh
   1129 
   1130 template<class _Tp>
   1131 complex<_Tp>
   1132 asinh(const complex<_Tp>& __x)
   1133 {
   1134     const _Tp __pi(atan2(+0., -0.));
   1135     if (__libcpp_isinf(__x.real()))
   1136     {
   1137         if (__libcpp_isnan(__x.imag()))
   1138             return __x;
   1139         if (__libcpp_isinf(__x.imag()))
   1140             return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
   1141         return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
   1142     }
   1143     if (__libcpp_isnan(__x.real()))
   1144     {
   1145         if (__libcpp_isinf(__x.imag()))
   1146             return complex<_Tp>(__x.imag(), __x.real());
   1147         if (__x.imag() == 0)
   1148             return __x;
   1149         return complex<_Tp>(__x.real(), __x.real());
   1150     }
   1151     if (__libcpp_isinf(__x.imag()))
   1152         return complex<_Tp>(copysign(__x.imag(), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
   1153     complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) + _Tp(1)));
   1154     return complex<_Tp>(copysign(__z.real(), __x.real()), copysign(__z.imag(), __x.imag()));
   1155 }
   1156 
   1157 // acosh
   1158 
   1159 template<class _Tp>
   1160 complex<_Tp>
   1161 acosh(const complex<_Tp>& __x)
   1162 {
   1163     const _Tp __pi(atan2(+0., -0.));
   1164     if (__libcpp_isinf(__x.real()))
   1165     {
   1166         if (__libcpp_isnan(__x.imag()))
   1167             return complex<_Tp>(abs(__x.real()), __x.imag());
   1168         if (__libcpp_isinf(__x.imag()))
   1169         {
   1170             if (__x.real() > 0)
   1171                 return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
   1172             else
   1173                 return complex<_Tp>(-__x.real(), copysign(__pi * _Tp(0.75), __x.imag()));
   1174         }
   1175         if (__x.real() < 0)
   1176             return complex<_Tp>(-__x.real(), copysign(__pi, __x.imag()));
   1177         return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
   1178     }
   1179     if (__libcpp_isnan(__x.real()))
   1180     {
   1181         if (__libcpp_isinf(__x.imag()))
   1182             return complex<_Tp>(abs(__x.imag()), __x.real());
   1183         return complex<_Tp>(__x.real(), __x.real());
   1184     }
   1185     if (__libcpp_isinf(__x.imag()))
   1186         return complex<_Tp>(abs(__x.imag()), copysign(__pi/_Tp(2), __x.imag()));
   1187     complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) - _Tp(1)));
   1188     return complex<_Tp>(copysign(__z.real(), _Tp(0)), copysign(__z.imag(), __x.imag()));
   1189 }
   1190 
   1191 // atanh
   1192 
   1193 template<class _Tp>
   1194 complex<_Tp>
   1195 atanh(const complex<_Tp>& __x)
   1196 {
   1197     const _Tp __pi(atan2(+0., -0.));
   1198     if (__libcpp_isinf(__x.imag()))
   1199     {
   1200         return complex<_Tp>(copysign(_Tp(0), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
   1201     }
   1202     if (__libcpp_isnan(__x.imag()))
   1203     {
   1204         if (__libcpp_isinf(__x.real()) || __x.real() == 0)
   1205             return complex<_Tp>(copysign(_Tp(0), __x.real()), __x.imag());
   1206         return complex<_Tp>(__x.imag(), __x.imag());
   1207     }
   1208     if (__libcpp_isnan(__x.real()))
   1209     {
   1210         return complex<_Tp>(__x.real(), __x.real());
   1211     }
   1212     if (__libcpp_isinf(__x.real()))
   1213     {
   1214         return complex<_Tp>(copysign(_Tp(0), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
   1215     }
   1216     if (abs(__x.real()) == _Tp(1) && __x.imag() == _Tp(0))
   1217     {
   1218         return complex<_Tp>(copysign(_Tp(INFINITY), __x.real()), copysign(_Tp(0), __x.imag()));
   1219     }
   1220     complex<_Tp> __z = log((_Tp(1) + __x) / (_Tp(1) - __x)) / _Tp(2);
   1221     return complex<_Tp>(copysign(__z.real(), __x.real()), copysign(__z.imag(), __x.imag()));
   1222 }
   1223 
   1224 // sinh
   1225 
   1226 template<class _Tp>
   1227 complex<_Tp>
   1228 sinh(const complex<_Tp>& __x)
   1229 {
   1230     if (__libcpp_isinf(__x.real()) && !__libcpp_isfinite(__x.imag()))
   1231         return complex<_Tp>(__x.real(), _Tp(NAN));
   1232     if (__x.real() == 0 && !__libcpp_isfinite(__x.imag()))
   1233         return complex<_Tp>(__x.real(), _Tp(NAN));
   1234     if (__x.imag() == 0 && !__libcpp_isfinite(__x.real()))
   1235         return __x;
   1236     return complex<_Tp>(sinh(__x.real()) * cos(__x.imag()), cosh(__x.real()) * sin(__x.imag()));
   1237 }
   1238 
   1239 // cosh
   1240 
   1241 template<class _Tp>
   1242 complex<_Tp>
   1243 cosh(const complex<_Tp>& __x)
   1244 {
   1245     if (__libcpp_isinf(__x.real()) && !__libcpp_isfinite(__x.imag()))
   1246         return complex<_Tp>(abs(__x.real()), _Tp(NAN));
   1247     if (__x.real() == 0 && !__libcpp_isfinite(__x.imag()))
   1248         return complex<_Tp>(_Tp(NAN), __x.real());
   1249     if (__x.real() == 0 && __x.imag() == 0)
   1250         return complex<_Tp>(_Tp(1), __x.imag());
   1251     if (__x.imag() == 0 && !__libcpp_isfinite(__x.real()))
   1252         return complex<_Tp>(abs(__x.real()), __x.imag());
   1253     return complex<_Tp>(cosh(__x.real()) * cos(__x.imag()), sinh(__x.real()) * sin(__x.imag()));
   1254 }
   1255 
   1256 // tanh
   1257 
   1258 template<class _Tp>
   1259 complex<_Tp>
   1260 tanh(const complex<_Tp>& __x)
   1261 {
   1262     if (__libcpp_isinf(__x.real()))
   1263     {
   1264         if (!__libcpp_isfinite(__x.imag()))
   1265             return complex<_Tp>(_Tp(1), _Tp(0));
   1266         return complex<_Tp>(_Tp(1), copysign(_Tp(0), sin(_Tp(2) * __x.imag())));
   1267     }
   1268     if (__libcpp_isnan(__x.real()) && __x.imag() == 0)
   1269         return __x;
   1270     _Tp __2r(_Tp(2) * __x.real());
   1271     _Tp __2i(_Tp(2) * __x.imag());
   1272     _Tp __d(cosh(__2r) + cos(__2i));
   1273     _Tp __2rsh(sinh(__2r));
   1274     if (__libcpp_isinf(__2rsh) && __libcpp_isinf(__d))
   1275         return complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1),
   1276                             __2i > _Tp(0) ? _Tp(0) : _Tp(-0.));
   1277     return  complex<_Tp>(__2rsh/__d, sin(__2i)/__d);
   1278 }
   1279 
   1280 // asin
   1281 
   1282 template<class _Tp>
   1283 complex<_Tp>
   1284 asin(const complex<_Tp>& __x)
   1285 {
   1286     complex<_Tp> __z = asinh(complex<_Tp>(-__x.imag(), __x.real()));
   1287     return complex<_Tp>(__z.imag(), -__z.real());
   1288 }
   1289 
   1290 // acos
   1291 
   1292 template<class _Tp>
   1293 complex<_Tp>
   1294 acos(const complex<_Tp>& __x)
   1295 {
   1296     const _Tp __pi(atan2(+0., -0.));
   1297     if (__libcpp_isinf(__x.real()))
   1298     {
   1299         if (__libcpp_isnan(__x.imag()))
   1300             return complex<_Tp>(__x.imag(), __x.real());
   1301         if (__libcpp_isinf(__x.imag()))
   1302         {
   1303             if (__x.real() < _Tp(0))
   1304                 return complex<_Tp>(_Tp(0.75) * __pi, -__x.imag());
   1305             return complex<_Tp>(_Tp(0.25) * __pi, -__x.imag());
   1306         }
   1307         if (__x.real() < _Tp(0))
   1308             return complex<_Tp>(__pi, signbit(__x.imag()) ? -__x.real() : __x.real());
   1309         return complex<_Tp>(_Tp(0), signbit(__x.imag()) ? __x.real() : -__x.real());
   1310     }
   1311     if (__libcpp_isnan(__x.real()))
   1312     {
   1313         if (__libcpp_isinf(__x.imag()))
   1314             return complex<_Tp>(__x.real(), -__x.imag());
   1315         return complex<_Tp>(__x.real(), __x.real());
   1316     }
   1317     if (__libcpp_isinf(__x.imag()))
   1318         return complex<_Tp>(__pi/_Tp(2), -__x.imag());
   1319     if (__x.real() == 0 && (__x.imag() == 0 || isnan(__x.imag())))
   1320         return complex<_Tp>(__pi/_Tp(2), -__x.imag());
   1321     complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) - _Tp(1)));
   1322     if (signbit(__x.imag()))
   1323         return complex<_Tp>(abs(__z.imag()), abs(__z.real()));
   1324     return complex<_Tp>(abs(__z.imag()), -abs(__z.real()));
   1325 }
   1326 
   1327 // atan
   1328 
   1329 template<class _Tp>
   1330 complex<_Tp>
   1331 atan(const complex<_Tp>& __x)
   1332 {
   1333     complex<_Tp> __z = atanh(complex<_Tp>(-__x.imag(), __x.real()));
   1334     return complex<_Tp>(__z.imag(), -__z.real());
   1335 }
   1336 
   1337 // sin
   1338 
   1339 template<class _Tp>
   1340 complex<_Tp>
   1341 sin(const complex<_Tp>& __x)
   1342 {
   1343     complex<_Tp> __z = sinh(complex<_Tp>(-__x.imag(), __x.real()));
   1344     return complex<_Tp>(__z.imag(), -__z.real());
   1345 }
   1346 
   1347 // cos
   1348 
   1349 template<class _Tp>
   1350 inline _LIBCPP_INLINE_VISIBILITY
   1351 complex<_Tp>
   1352 cos(const complex<_Tp>& __x)
   1353 {
   1354     return cosh(complex<_Tp>(-__x.imag(), __x.real()));
   1355 }
   1356 
   1357 // tan
   1358 
   1359 template<class _Tp>
   1360 complex<_Tp>
   1361 tan(const complex<_Tp>& __x)
   1362 {
   1363     complex<_Tp> __z = tanh(complex<_Tp>(-__x.imag(), __x.real()));
   1364     return complex<_Tp>(__z.imag(), -__z.real());
   1365 }
   1366 
   1367 template<class _Tp, class _CharT, class _Traits>
   1368 basic_istream<_CharT, _Traits>&
   1369 operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
   1370 {
   1371     if (__is.good())
   1372     {
   1373         ws(__is);
   1374         if (__is.peek() == _CharT('('))
   1375         {
   1376             __is.get();
   1377             _Tp __r;
   1378             __is >> __r;
   1379             if (!__is.fail())
   1380             {
   1381                 ws(__is);
   1382                 _CharT __c = __is.peek();
   1383                 if (__c == _CharT(','))
   1384                 {
   1385                     __is.get();
   1386                     _Tp __i;
   1387                     __is >> __i;
   1388                     if (!__is.fail())
   1389                     {
   1390                         ws(__is);
   1391                         __c = __is.peek();
   1392                         if (__c == _CharT(')'))
   1393                         {
   1394                             __is.get();
   1395                             __x = complex<_Tp>(__r, __i);
   1396                         }
   1397                         else
   1398                             __is.setstate(ios_base::failbit);
   1399                     }
   1400                     else
   1401                         __is.setstate(ios_base::failbit);
   1402                 }
   1403                 else if (__c == _CharT(')'))
   1404                 {
   1405                     __is.get();
   1406                     __x = complex<_Tp>(__r, _Tp(0));
   1407                 }
   1408                 else
   1409                     __is.setstate(ios_base::failbit);
   1410             }
   1411             else
   1412                 __is.setstate(ios_base::failbit);
   1413         }
   1414         else
   1415         {
   1416             _Tp __r;
   1417             __is >> __r;
   1418             if (!__is.fail())
   1419                 __x = complex<_Tp>(__r, _Tp(0));
   1420             else
   1421                 __is.setstate(ios_base::failbit);
   1422         }
   1423     }
   1424     else
   1425         __is.setstate(ios_base::failbit);
   1426     return __is;
   1427 }
   1428 
   1429 template<class _Tp, class _CharT, class _Traits>
   1430 basic_ostream<_CharT, _Traits>&
   1431 operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
   1432 {
   1433     basic_ostringstream<_CharT, _Traits> __s;
   1434     __s.flags(__os.flags());
   1435     __s.imbue(__os.getloc());
   1436     __s.precision(__os.precision());
   1437     __s << '(' << __x.real() << ',' << __x.imag() << ')';
   1438     return __os << __s.str();
   1439 }
   1440 
   1441 #if _LIBCPP_STD_VER > 11 
   1442 // Literal suffix for complex number literals [complex.literals]
   1443 inline namespace literals
   1444 { 
   1445   inline namespace complex_literals
   1446   {
   1447     constexpr complex<long double> operator""il(long double __im)
   1448     {
   1449         return { 0.0l, __im };
   1450     }
   1451 
   1452     constexpr complex<long double> operator""il(unsigned long long __im)
   1453     {
   1454         return { 0.0l, static_cast<long double>(__im) };
   1455     }
   1456 
   1457 
   1458     constexpr complex<double> operator""i(long double __im)
   1459     {
   1460         return { 0.0, static_cast<double>(__im) };
   1461     }
   1462 
   1463     constexpr complex<double> operator""i(unsigned long long __im)
   1464     {
   1465         return { 0.0, static_cast<double>(__im) };
   1466     }
   1467 
   1468 
   1469     constexpr complex<float> operator""if(long double __im)
   1470     {
   1471         return { 0.0f, static_cast<float>(__im) };
   1472     }
   1473 
   1474     constexpr complex<float> operator""if(unsigned long long __im)
   1475     {
   1476         return { 0.0f, static_cast<float>(__im) };
   1477     }
   1478   }
   1479 }
   1480 #endif
   1481 
   1482 _LIBCPP_END_NAMESPACE_STD
   1483 
   1484 #endif  // _LIBCPP_COMPLEX
   1485