contrib/libc++/include/complex

   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 #if defined(_LIBCPP_NO_EXCEPTIONS)
 249     #include <cassert>
 250 #endif
 251
 252 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 253 #pragma GCC system_header
 254 #endif
 255
 256 _LIBCPP_BEGIN_NAMESPACE_STD
 257
 258 template<class _Tp> class _LIBCPP_TYPE_VIS_ONLY complex;
 259
 260 template<class _Tp> complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
 261 template<class _Tp> complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
 262
 263 template<class _Tp>
 264 class _LIBCPP_TYPE_VIS_ONLY complex
 265 {
 266 public:
 267     typedef _Tp value_type;
 268 private:
 269     value_type __re_;
 270     value_type __im_;
 271 public:
 272     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 273     complex(const value_type& __re = value_type(), const value_type& __im = value_type())
 274         : __re_(__re), __im_(__im) {}
 275     template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 276     complex(const complex<_Xp>& __c)
 277         : __re_(__c.real()), __im_(__c.imag()) {}
 278
 279     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 value_type real() const {return __re_;}
 280     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 value_type imag() const {return __im_;}
 281
 282     _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
 283     _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
 284
 285     _LIBCPP_INLINE_VISIBILITY complex& operator= (const value_type& __re)
 286         {__re_ = __re; __im_ = value_type(); return *this;}
 287     _LIBCPP_INLINE_VISIBILITY complex& operator+=(const value_type& __re) {__re_ += __re; return *this;}
 288     _LIBCPP_INLINE_VISIBILITY complex& operator-=(const value_type& __re) {__re_ -= __re; return *this;}
 289     _LIBCPP_INLINE_VISIBILITY complex& operator*=(const value_type& __re) {__re_ *= __re; __im_ *= __re; return *this;}
 290     _LIBCPP_INLINE_VISIBILITY complex& operator/=(const value_type& __re) {__re_ /= __re; __im_ /= __re; return *this;}
 291
 292     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
 293         {
 294             __re_ = __c.real();
 295             __im_ = __c.imag();
 296             return *this;
 297         }
 298     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
 299         {
 300             __re_ += __c.real();
 301             __im_ += __c.imag();
 302             return *this;
 303         }
 304     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
 305         {
 306             __re_ -= __c.real();
 307             __im_ -= __c.imag();
 308             return *this;
 309         }
 310     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
 311         {
 312             *this = *this * complex(__c.real(), __c.imag());
 313             return *this;
 314         }
 315     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
 316         {
 317             *this = *this / complex(__c.real(), __c.imag());
 318             return *this;
 319         }
 320 };
 321
 322 template<> class _LIBCPP_TYPE_VIS_ONLY complex<double>;
 323 template<> class _LIBCPP_TYPE_VIS_ONLY complex<long double>;
 324
 325 template<>
 326 class _LIBCPP_TYPE_VIS_ONLY complex<float>
 327 {
 328     float __re_;
 329     float __im_;
 330 public:
 331     typedef float value_type;
 332
 333     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(float __re = 0.0f, float __im = 0.0f)
 334         : __re_(__re), __im_(__im) {}
 335     _LIBCPP_INLINE_VISIBILITY
 336     explicit _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
 337     _LIBCPP_INLINE_VISIBILITY
 338     explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
 339
 340     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float real() const {return __re_;}
 341     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float imag() const {return __im_;}
 342
 343     _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
 344     _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
 345
 346     _LIBCPP_INLINE_VISIBILITY complex& operator= (float __re)
 347         {__re_ = __re; __im_ = value_type(); return *this;}
 348     _LIBCPP_INLINE_VISIBILITY complex& operator+=(float __re) {__re_ += __re; return *this;}
 349     _LIBCPP_INLINE_VISIBILITY complex& operator-=(float __re) {__re_ -= __re; return *this;}
 350     _LIBCPP_INLINE_VISIBILITY complex& operator*=(float __re) {__re_ *= __re; __im_ *= __re; return *this;}
 351     _LIBCPP_INLINE_VISIBILITY complex& operator/=(float __re) {__re_ /= __re; __im_ /= __re; return *this;}
 352
 353     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
 354         {
 355             __re_ = __c.real();
 356             __im_ = __c.imag();
 357             return *this;
 358         }
 359     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
 360         {
 361             __re_ += __c.real();
 362             __im_ += __c.imag();
 363             return *this;
 364         }
 365     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
 366         {
 367             __re_ -= __c.real();
 368             __im_ -= __c.imag();
 369             return *this;
 370         }
 371     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
 372         {
 373             *this = *this * complex(__c.real(), __c.imag());
 374             return *this;
 375         }
 376     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
 377         {
 378             *this = *this / complex(__c.real(), __c.imag());
 379             return *this;
 380         }
 381 };
 382
 383 template<>
 384 class _LIBCPP_TYPE_VIS_ONLY complex<double>
 385 {
 386     double __re_;
 387     double __im_;
 388 public:
 389     typedef double value_type;
 390
 391     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(double __re = 0.0, double __im = 0.0)
 392         : __re_(__re), __im_(__im) {}
 393     _LIBCPP_INLINE_VISIBILITY
 394     _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
 395     _LIBCPP_INLINE_VISIBILITY
 396     explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
 397
 398     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double real() const {return __re_;}
 399     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double imag() const {return __im_;}
 400
 401     _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
 402     _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
 403
 404     _LIBCPP_INLINE_VISIBILITY complex& operator= (double __re)
 405         {__re_ = __re; __im_ = value_type(); return *this;}
 406     _LIBCPP_INLINE_VISIBILITY complex& operator+=(double __re) {__re_ += __re; return *this;}
 407     _LIBCPP_INLINE_VISIBILITY complex& operator-=(double __re) {__re_ -= __re; return *this;}
 408     _LIBCPP_INLINE_VISIBILITY complex& operator*=(double __re) {__re_ *= __re; __im_ *= __re; return *this;}
 409     _LIBCPP_INLINE_VISIBILITY complex& operator/=(double __re) {__re_ /= __re; __im_ /= __re; return *this;}
 410
 411     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
 412         {
 413             __re_ = __c.real();
 414             __im_ = __c.imag();
 415             return *this;
 416         }
 417     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
 418         {
 419             __re_ += __c.real();
 420             __im_ += __c.imag();
 421             return *this;
 422         }
 423     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
 424         {
 425             __re_ -= __c.real();
 426             __im_ -= __c.imag();
 427             return *this;
 428         }
 429     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
 430         {
 431             *this = *this * complex(__c.real(), __c.imag());
 432             return *this;
 433         }
 434     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
 435         {
 436             *this = *this / complex(__c.real(), __c.imag());
 437             return *this;
 438         }
 439 };
 440
 441 template<>
 442 class _LIBCPP_TYPE_VIS_ONLY complex<long double>
 443 {
 444     long double __re_;
 445     long double __im_;
 446 public:
 447     typedef long double value_type;
 448
 449     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(long double __re = 0.0L, long double __im = 0.0L)
 450         : __re_(__re), __im_(__im) {}
 451     _LIBCPP_INLINE_VISIBILITY
 452     _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
 453     _LIBCPP_INLINE_VISIBILITY
 454     _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
 455
 456     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double real() const {return __re_;}
 457     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double imag() const {return __im_;}
 458
 459     _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
 460     _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
 461
 462     _LIBCPP_INLINE_VISIBILITY complex& operator= (long double __re)
 463         {__re_ = __re; __im_ = value_type(); return *this;}
 464     _LIBCPP_INLINE_VISIBILITY complex& operator+=(long double __re) {__re_ += __re; return *this;}
 465     _LIBCPP_INLINE_VISIBILITY complex& operator-=(long double __re) {__re_ -= __re; return *this;}
 466     _LIBCPP_INLINE_VISIBILITY complex& operator*=(long double __re) {__re_ *= __re; __im_ *= __re; return *this;}
 467     _LIBCPP_INLINE_VISIBILITY complex& operator/=(long double __re) {__re_ /= __re; __im_ /= __re; return *this;}
 468
 469     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
 470         {
 471             __re_ = __c.real();
 472             __im_ = __c.imag();
 473             return *this;
 474         }
 475     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
 476         {
 477             __re_ += __c.real();
 478             __im_ += __c.imag();
 479             return *this;
 480         }
 481     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
 482         {
 483             __re_ -= __c.real();
 484             __im_ -= __c.imag();
 485             return *this;
 486         }
 487     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
 488         {
 489             *this = *this * complex(__c.real(), __c.imag());
 490             return *this;
 491         }
 492     template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
 493         {
 494             *this = *this / complex(__c.real(), __c.imag());
 495             return *this;
 496         }
 497 };
 498
 499 inline
 500 _LIBCPP_CONSTEXPR
 501 complex<float>::complex(const complex<double>& __c)
 502     : __re_(__c.real()), __im_(__c.imag()) {}
 503
 504 inline
 505 _LIBCPP_CONSTEXPR
 506 complex<float>::complex(const complex<long double>& __c)
 507     : __re_(__c.real()), __im_(__c.imag()) {}
 508
 509 inline
 510 _LIBCPP_CONSTEXPR
 511 complex<double>::complex(const complex<float>& __c)
 512     : __re_(__c.real()), __im_(__c.imag()) {}
 513
 514 inline
 515 _LIBCPP_CONSTEXPR
 516 complex<double>::complex(const complex<long double>& __c)
 517     : __re_(__c.real()), __im_(__c.imag()) {}
 518
 519 inline
 520 _LIBCPP_CONSTEXPR
 521 complex<long double>::complex(const complex<float>& __c)
 522     : __re_(__c.real()), __im_(__c.imag()) {}
 523
 524 inline
 525 _LIBCPP_CONSTEXPR
 526 complex<long double>::complex(const complex<double>& __c)
 527     : __re_(__c.real()), __im_(__c.imag()) {}
 528
 529 // 26.3.6 operators:
 530
 531 template<class _Tp>
 532 inline _LIBCPP_INLINE_VISIBILITY
 533 complex<_Tp>
 534 operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
 535 {
 536     complex<_Tp> __t(__x);
 537     __t += __y;
 538     return __t;
 539 }
 540
 541 template<class _Tp>
 542 inline _LIBCPP_INLINE_VISIBILITY
 543 complex<_Tp>
 544 operator+(const complex<_Tp>& __x, const _Tp& __y)
 545 {
 546     complex<_Tp> __t(__x);
 547     __t += __y;
 548     return __t;
 549 }
 550
 551 template<class _Tp>
 552 inline _LIBCPP_INLINE_VISIBILITY
 553 complex<_Tp>
 554 operator+(const _Tp& __x, const complex<_Tp>& __y)
 555 {
 556     complex<_Tp> __t(__y);
 557     __t += __x;
 558     return __t;
 559 }
 560
 561 template<class _Tp>
 562 inline _LIBCPP_INLINE_VISIBILITY
 563 complex<_Tp>
 564 operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
 565 {
 566     complex<_Tp> __t(__x);
 567     __t -= __y;
 568     return __t;
 569 }
 570
 571 template<class _Tp>
 572 inline _LIBCPP_INLINE_VISIBILITY
 573 complex<_Tp>
 574 operator-(const complex<_Tp>& __x, const _Tp& __y)
 575 {
 576     complex<_Tp> __t(__x);
 577     __t -= __y;
 578     return __t;
 579 }
 580
 581 template<class _Tp>
 582 inline _LIBCPP_INLINE_VISIBILITY
 583 complex<_Tp>
 584 operator-(const _Tp& __x, const complex<_Tp>& __y)
 585 {
 586     complex<_Tp> __t(-__y);
 587     __t += __x;
 588     return __t;
 589 }
 590
 591 template<class _Tp>
 592 complex<_Tp>
 593 operator*(const complex<_Tp>& __z, const complex<_Tp>& __w)
 594 {
 595     _Tp __a = __z.real();
 596     _Tp __b = __z.imag();
 597     _Tp __c = __w.real();
 598     _Tp __d = __w.imag();
 599     _Tp __ac = __a * __c;
 600     _Tp __bd = __b * __d;
 601     _Tp __ad = __a * __d;
 602     _Tp __bc = __b * __c;
 603     _Tp __x = __ac - __bd;
 604     _Tp __y = __ad + __bc;
 605     if (isnan(__x) && isnan(__y))
 606     {
 607         bool __recalc = false;
 608         if (isinf(__a) || isinf(__b))
 609         {
 610             __a = copysign(isinf(__a) ? _Tp(1) : _Tp(0), __a);
 611             __b = copysign(isinf(__b) ? _Tp(1) : _Tp(0), __b);
 612             if (isnan(__c))
 613                 __c = copysign(_Tp(0), __c);
 614             if (isnan(__d))
 615                 __d = copysign(_Tp(0), __d);
 616             __recalc = true;
 617         }
 618         if (isinf(__c) || isinf(__d))
 619         {
 620             __c = copysign(isinf(__c) ? _Tp(1) : _Tp(0), __c);
 621             __d = copysign(isinf(__d) ? _Tp(1) : _Tp(0), __d);
 622             if (isnan(__a))
 623                 __a = copysign(_Tp(0), __a);
 624             if (isnan(__b))
 625                 __b = copysign(_Tp(0), __b);
 626             __recalc = true;
 627         }
 628         if (!__recalc && (isinf(__ac) || isinf(__bd) ||
 629                           isinf(__ad) || isinf(__bc)))
 630         {
 631             if (isnan(__a))
 632                 __a = copysign(_Tp(0), __a);
 633             if (isnan(__b))
 634                 __b = copysign(_Tp(0), __b);
 635             if (isnan(__c))
 636                 __c = copysign(_Tp(0), __c);
 637             if (isnan(__d))
 638                 __d = copysign(_Tp(0), __d);
 639             __recalc = true;
 640         }
 641         if (__recalc)
 642         {
 643             __x = _Tp(INFINITY) * (__a * __c - __b * __d);
 644             __y = _Tp(INFINITY) * (__a * __d + __b * __c);
 645         }
 646     }
 647     return complex<_Tp>(__x, __y);
 648 }
 649
 650 template<class _Tp>
 651 inline _LIBCPP_INLINE_VISIBILITY
 652 complex<_Tp>
 653 operator*(const complex<_Tp>& __x, const _Tp& __y)
 654 {
 655     complex<_Tp> __t(__x);
 656     __t *= __y;
 657     return __t;
 658 }
 659
 660 template<class _Tp>
 661 inline _LIBCPP_INLINE_VISIBILITY
 662 complex<_Tp>
 663 operator*(const _Tp& __x, const complex<_Tp>& __y)
 664 {
 665     complex<_Tp> __t(__y);
 666     __t *= __x;
 667     return __t;
 668 }
 669
 670 template<class _Tp>
 671 complex<_Tp>
 672 operator/(const complex<_Tp>& __z, const complex<_Tp>& __w)
 673 {
 674     int __ilogbw = 0;
 675     _Tp __a = __z.real();
 676     _Tp __b = __z.imag();
 677     _Tp __c = __w.real();
 678     _Tp __d = __w.imag();
 679     _Tp __logbw = logb(fmax(fabs(__c), fabs(__d)));
 680     if (isfinite(__logbw))
 681     {
 682         __ilogbw = static_cast<int>(__logbw);
 683         __c = scalbn(__c, -__ilogbw);
 684         __d = scalbn(__d, -__ilogbw);
 685     }
 686     _Tp __denom = __c * __c + __d * __d;
 687     _Tp __x = scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
 688     _Tp __y = scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
 689     if (isnan(__x) && isnan(__y))
 690     {
 691         if ((__denom == _Tp(0)) && (!isnan(__a) || !isnan(__b)))
 692         {
 693             __x = copysign(_Tp(INFINITY), __c) * __a;
 694             __y = copysign(_Tp(INFINITY), __c) * __b;
 695         }
 696         else if ((isinf(__a) || isinf(__b)) && isfinite(__c) && isfinite(__d))
 697         {
 698             __a = copysign(isinf(__a) ? _Tp(1) : _Tp(0), __a);
 699             __b = copysign(isinf(__b) ? _Tp(1) : _Tp(0), __b);
 700             __x = _Tp(INFINITY) * (__a * __c + __b * __d);
 701             __y = _Tp(INFINITY) * (__b * __c - __a * __d);
 702         }
 703         else if (isinf(__logbw) && __logbw > _Tp(0) && isfinite(__a) && isfinite(__b))
 704         {
 705             __c = copysign(isinf(__c) ? _Tp(1) : _Tp(0), __c);
 706             __d = copysign(isinf(__d) ? _Tp(1) : _Tp(0), __d);
 707             __x = _Tp(0) * (__a * __c + __b * __d);
 708             __y = _Tp(0) * (__b * __c - __a * __d);
 709         }
 710     }
 711     return complex<_Tp>(__x, __y);
 712 }
 713
 714 template<class _Tp>
 715 inline _LIBCPP_INLINE_VISIBILITY
 716 complex<_Tp>
 717 operator/(const complex<_Tp>& __x, const _Tp& __y)
 718 {
 719     return complex<_Tp>(__x.real() / __y, __x.imag() / __y);
 720 }
 721
 722 template<class _Tp>
 723 inline _LIBCPP_INLINE_VISIBILITY
 724 complex<_Tp>
 725 operator/(const _Tp& __x, const complex<_Tp>& __y)
 726 {
 727     complex<_Tp> __t(__x);
 728     __t /= __y;
 729     return __t;
 730 }
 731
 732 template<class _Tp>
 733 inline _LIBCPP_INLINE_VISIBILITY
 734 complex<_Tp>
 735 operator+(const complex<_Tp>& __x)
 736 {
 737     return __x;
 738 }
 739
 740 template<class _Tp>
 741 inline _LIBCPP_INLINE_VISIBILITY
 742 complex<_Tp>
 743 operator-(const complex<_Tp>& __x)
 744 {
 745     return complex<_Tp>(-__x.real(), -__x.imag());
 746 }
 747
 748 template<class _Tp>
 749 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 750 bool
 751 operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
 752 {
 753     return __x.real() == __y.real() && __x.imag() == __y.imag();
 754 }
 755
 756 template<class _Tp>
 757 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 758 bool
 759 operator==(const complex<_Tp>& __x, const _Tp& __y)
 760 {
 761     return __x.real() == __y && __x.imag() == 0;
 762 }
 763
 764 template<class _Tp>
 765 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 766 bool
 767 operator==(const _Tp& __x, const complex<_Tp>& __y)
 768 {
 769     return __x == __y.real() && 0 == __y.imag();
 770 }
 771
 772 template<class _Tp>
 773 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 774 bool
 775 operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
 776 {
 777     return !(__x == __y);
 778 }
 779
 780 template<class _Tp>
 781 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 782 bool
 783 operator!=(const complex<_Tp>& __x, const _Tp& __y)
 784 {
 785     return !(__x == __y);
 786 }
 787
 788 template<class _Tp>
 789 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 790 bool
 791 operator!=(const _Tp& __x, const complex<_Tp>& __y)
 792 {
 793     return !(__x == __y);
 794 }
 795
 796 // 26.3.7 values:
 797
 798 // real
 799
 800 template<class _Tp>
 801 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 802 _Tp
 803 real(const complex<_Tp>& __c)
 804 {
 805     return __c.real();
 806 }
 807
 808 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 809 long double
 810 real(long double __re)
 811 {
 812     return __re;
 813 }
 814
 815 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 816 double
 817 real(double __re)
 818 {
 819     return __re;
 820 }
 821
 822 template<class _Tp>
 823 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 824 typename enable_if
 825 <
 826     is_integral<_Tp>::value,
 827     double
 828 >::type
 829 real(_Tp  __re)
 830 {
 831     return __re;
 832 }
 833
 834 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 835 float
 836 real(float  __re)
 837 {
 838     return __re;
 839 }
 840
 841 // imag
 842
 843 template<class _Tp>
 844 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 845 _Tp
 846 imag(const complex<_Tp>& __c)
 847 {
 848     return __c.imag();
 849 }
 850
 851 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 852 long double
 853 imag(long double __re)
 854 {
 855     return 0;
 856 }
 857
 858 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 859 double
 860 imag(double __re)
 861 {
 862     return 0;
 863 }
 864
 865 template<class _Tp>
 866 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 867 typename enable_if
 868 <
 869     is_integral<_Tp>::value,
 870     double
 871 >::type
 872 imag(_Tp  __re)
 873 {
 874     return 0;
 875 }
 876
 877 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 878 float
 879 imag(float  __re)
 880 {
 881     return 0;
 882 }
 883
 884 // abs
 885
 886 template<class _Tp>
 887 inline _LIBCPP_INLINE_VISIBILITY
 888 _Tp
 889 abs(const complex<_Tp>& __c)
 890 {
 891     return hypot(__c.real(), __c.imag());
 892 }
 893
 894 // arg
 895
 896 template<class _Tp>
 897 inline _LIBCPP_INLINE_VISIBILITY
 898 _Tp
 899 arg(const complex<_Tp>& __c)
 900 {
 901     return atan2(__c.imag(), __c.real());
 902 }
 903
 904 inline _LIBCPP_INLINE_VISIBILITY
 905 long double
 906 arg(long double __re)
 907 {
 908     return atan2l(0.L, __re);
 909 }
 910
 911 inline _LIBCPP_INLINE_VISIBILITY
 912 double
 913 arg(double __re)
 914 {
 915     return atan2(0., __re);
 916 }
 917
 918 template<class _Tp>
 919 inline _LIBCPP_INLINE_VISIBILITY
 920 typename enable_if
 921 <
 922     is_integral<_Tp>::value,
 923     double
 924 >::type
 925 arg(_Tp __re)
 926 {
 927     return atan2(0., __re);
 928 }
 929
 930 inline _LIBCPP_INLINE_VISIBILITY
 931 float
 932 arg(float __re)
 933 {
 934     return atan2f(0.F, __re);
 935 }
 936
 937 // norm
 938
 939 template<class _Tp>
 940 inline _LIBCPP_INLINE_VISIBILITY
 941 _Tp
 942 norm(const complex<_Tp>& __c)
 943 {
 944     if (isinf(__c.real()))
 945         return abs(__c.real());
 946     if (isinf(__c.imag()))
 947         return abs(__c.imag());
 948     return __c.real() * __c.real() + __c.imag() * __c.imag();
 949 }
 950
 951 inline _LIBCPP_INLINE_VISIBILITY
 952 long double
 953 norm(long double __re)
 954 {
 955     return __re * __re;
 956 }
 957
 958 inline _LIBCPP_INLINE_VISIBILITY
 959 double
 960 norm(double __re)
 961 {
 962     return __re * __re;
 963 }
 964
 965 template<class _Tp>
 966 inline _LIBCPP_INLINE_VISIBILITY
 967 typename enable_if
 968 <
 969     is_integral<_Tp>::value,
 970     double
 971 >::type
 972 norm(_Tp __re)
 973 {
 974     return (double)__re * __re;
 975 }
 976
 977 inline _LIBCPP_INLINE_VISIBILITY
 978 float
 979 norm(float __re)
 980 {
 981     return __re * __re;
 982 }
 983
 984 // conj
 985
 986 template<class _Tp>
 987 inline _LIBCPP_INLINE_VISIBILITY
 988 complex<_Tp>
 989 conj(const complex<_Tp>& __c)
 990 {
 991     return complex<_Tp>(__c.real(), -__c.imag());
 992 }
 993
 994 inline _LIBCPP_INLINE_VISIBILITY
 995 complex<long double>
 996 conj(long double __re)
 997 {
 998     return complex<long double>(__re);
 999 }
1000
1001 inline _LIBCPP_INLINE_VISIBILITY
1002 complex<double>
1003 conj(double __re)
1004 {
1005     return complex<double>(__re);
1006 }
1007
1008 template<class _Tp>
1009 inline _LIBCPP_INLINE_VISIBILITY
1010 typename enable_if
1011 <
1012     is_integral<_Tp>::value,
1013     complex<double>
1014 >::type
1015 conj(_Tp __re)
1016 {
1017     return complex<double>(__re);
1018 }
1019
1020 inline _LIBCPP_INLINE_VISIBILITY
1021 complex<float>
1022 conj(float __re)
1023 {
1024     return complex<float>(__re);
1025 }
1026
1027 // proj
1028
1029 template<class _Tp>
1030 inline _LIBCPP_INLINE_VISIBILITY
1031 complex<_Tp>
1032 proj(const complex<_Tp>& __c)
1033 {
1034     std::complex<_Tp> __r = __c;
1035     if (isinf(__c.real()) || isinf(__c.imag()))
1036         __r = complex<_Tp>(INFINITY, copysign(_Tp(0), __c.imag()));
1037     return __r;
1038 }
1039
1040 inline _LIBCPP_INLINE_VISIBILITY
1041 complex<long double>
1042 proj(long double __re)
1043 {
1044     if (isinf(__re))
1045         __re = abs(__re);
1046     return complex<long double>(__re);
1047 }
1048
1049 inline _LIBCPP_INLINE_VISIBILITY
1050 complex<double>
1051 proj(double __re)
1052 {
1053     if (isinf(__re))
1054         __re = abs(__re);
1055     return complex<double>(__re);
1056 }
1057
1058 template<class _Tp>
1059 inline _LIBCPP_INLINE_VISIBILITY
1060 typename enable_if
1061 <
1062     is_integral<_Tp>::value,
1063     complex<double>
1064 >::type
1065 proj(_Tp __re)
1066 {
1067     return complex<double>(__re);
1068 }
1069
1070 inline _LIBCPP_INLINE_VISIBILITY
1071 complex<float>
1072 proj(float __re)
1073 {
1074     if (isinf(__re))
1075         __re = abs(__re);
1076     return complex<float>(__re);
1077 }
1078
1079 // polar
1080
1081 template<class _Tp>
1082 complex<_Tp>
1083 polar(const _Tp& __rho, const _Tp& __theta = _Tp(0))
1084 {
1085     if (isnan(__rho) || signbit(__rho))
1086         return complex<_Tp>(_Tp(NAN), _Tp(NAN));
1087     if (isnan(__theta))
1088     {
1089         if (isinf(__rho))
1090             return complex<_Tp>(__rho, __theta);
1091         return complex<_Tp>(__theta, __theta);
1092     }
1093     if (isinf(__theta))
1094     {
1095         if (isinf(__rho))
1096             return complex<_Tp>(__rho, _Tp(NAN));
1097         return complex<_Tp>(_Tp(NAN), _Tp(NAN));
1098     }
1099     _Tp __x = __rho * cos(__theta);
1100     if (isnan(__x))
1101         __x = 0;
1102     _Tp __y = __rho * sin(__theta);
1103     if (isnan(__y))
1104         __y = 0;
1105     return complex<_Tp>(__x, __y);
1106 }
1107
1108 // log
1109
1110 template<class _Tp>
1111 inline _LIBCPP_INLINE_VISIBILITY
1112 complex<_Tp>
1113 log(const complex<_Tp>& __x)
1114 {
1115     return complex<_Tp>(log(abs(__x)), arg(__x));
1116 }
1117
1118 // log10
1119
1120 template<class _Tp>
1121 inline _LIBCPP_INLINE_VISIBILITY
1122 complex<_Tp>
1123 log10(const complex<_Tp>& __x)
1124 {
1125     return log(__x) / log(_Tp(10));
1126 }
1127
1128 // sqrt
1129
1130 template<class _Tp>
1131 complex<_Tp>
1132 sqrt(const complex<_Tp>& __x)
1133 {
1134     if (isinf(__x.imag()))
1135         return complex<_Tp>(_Tp(INFINITY), __x.imag());
1136     if (isinf(__x.real()))
1137     {
1138         if (__x.real() > _Tp(0))
1139             return complex<_Tp>(__x.real(), isnan(__x.imag()) ? __x.imag() : copysign(_Tp(0), __x.imag()));
1140         return complex<_Tp>(isnan(__x.imag()) ? __x.imag() : _Tp(0), copysign(__x.real(), __x.imag()));
1141     }
1142     return polar(sqrt(abs(__x)), arg(__x) / _Tp(2));
1143 }
1144
1145 // exp
1146
1147 template<class _Tp>
1148 complex<_Tp>
1149 exp(const complex<_Tp>& __x)
1150 {
1151     _Tp __i = __x.imag();
1152     if (isinf(__x.real()))
1153     {
1154         if (__x.real() < _Tp(0))
1155         {
1156             if (!isfinite(__i))
1157                 __i = _Tp(1);
1158         }
1159         else if (__i == 0 || !isfinite(__i))
1160         {
1161             if (isinf(__i))
1162                 __i = _Tp(NAN);
1163             return complex<_Tp>(__x.real(), __i);
1164         }
1165     }
1166     else if (isnan(__x.real()) && __x.imag() == 0)
1167         return __x;
1168     _Tp __e = exp(__x.real());
1169     return complex<_Tp>(__e * cos(__i), __e * sin(__i));
1170 }
1171
1172 // pow
1173
1174 template<class _Tp>
1175 inline _LIBCPP_INLINE_VISIBILITY
1176 complex<_Tp>
1177 pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1178 {
1179     return exp(__y * log(__x));
1180 }
1181
1182 template<class _Tp, class _Up>
1183 inline _LIBCPP_INLINE_VISIBILITY
1184 complex<typename __promote<_Tp, _Up>::type>
1185 pow(const complex<_Tp>& __x, const complex<_Up>& __y)
1186 {
1187     typedef complex<typename __promote<_Tp, _Up>::type> result_type;
1188     return _VSTD::pow(result_type(__x), result_type(__y));
1189 }
1190
1191 template<class _Tp, class _Up>
1192 inline _LIBCPP_INLINE_VISIBILITY
1193 typename enable_if
1194 <
1195     is_arithmetic<_Up>::value,
1196     complex<typename __promote<_Tp, _Up>::type>
1197 >::type
1198 pow(const complex<_Tp>& __x, const _Up& __y)
1199 {
1200     typedef complex<typename __promote<_Tp, _Up>::type> result_type;
1201     return _VSTD::pow(result_type(__x), result_type(__y));
1202 }
1203
1204 template<class _Tp, class _Up>
1205 inline _LIBCPP_INLINE_VISIBILITY
1206 typename enable_if
1207 <
1208     is_arithmetic<_Tp>::value,
1209     complex<typename __promote<_Tp, _Up>::type>
1210 >::type
1211 pow(const _Tp& __x, const complex<_Up>& __y)
1212 {
1213     typedef complex<typename __promote<_Tp, _Up>::type> result_type;
1214     return _VSTD::pow(result_type(__x), result_type(__y));
1215 }
1216
1217 // asinh
1218
1219 template<class _Tp>
1220 complex<_Tp>
1221 asinh(const complex<_Tp>& __x)
1222 {
1223     const _Tp __pi(atan2(+0., -0.));
1224     if (isinf(__x.real()))
1225     {
1226         if (isnan(__x.imag()))
1227             return __x;
1228         if (isinf(__x.imag()))
1229             return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
1230         return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
1231     }
1232     if (isnan(__x.real()))
1233     {
1234         if (isinf(__x.imag()))
1235             return complex<_Tp>(__x.imag(), __x.real());
1236         if (__x.imag() == 0)
1237             return __x;
1238         return complex<_Tp>(__x.real(), __x.real());
1239     }
1240     if (isinf(__x.imag()))
1241         return complex<_Tp>(copysign(__x.imag(), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
1242     complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) + _Tp(1)));
1243     return complex<_Tp>(copysign(__z.real(), __x.real()), copysign(__z.imag(), __x.imag()));
1244 }
1245
1246 // acosh
1247
1248 template<class _Tp>
1249 complex<_Tp>
1250 acosh(const complex<_Tp>& __x)
1251 {
1252     const _Tp __pi(atan2(+0., -0.));
1253     if (isinf(__x.real()))
1254     {
1255         if (isnan(__x.imag()))
1256             return complex<_Tp>(abs(__x.real()), __x.imag());
1257         if (isinf(__x.imag()))
1258         {
1259             if (__x.real() > 0)
1260                 return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
1261             else
1262                 return complex<_Tp>(-__x.real(), copysign(__pi * _Tp(0.75), __x.imag()));
1263         }
1264         if (__x.real() < 0)
1265             return complex<_Tp>(-__x.real(), copysign(__pi, __x.imag()));
1266         return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
1267     }
1268     if (isnan(__x.real()))
1269     {
1270         if (isinf(__x.imag()))
1271             return complex<_Tp>(abs(__x.imag()), __x.real());
1272         return complex<_Tp>(__x.real(), __x.real());
1273     }
1274     if (isinf(__x.imag()))
1275         return complex<_Tp>(abs(__x.imag()), copysign(__pi/_Tp(2), __x.imag()));
1276     complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) - _Tp(1)));
1277     return complex<_Tp>(copysign(__z.real(), _Tp(0)), copysign(__z.imag(), __x.imag()));
1278 }
1279
1280 // atanh
1281
1282 template<class _Tp>
1283 complex<_Tp>
1284 atanh(const complex<_Tp>& __x)
1285 {
1286     const _Tp __pi(atan2(+0., -0.));
1287     if (isinf(__x.imag()))
1288     {
1289         return complex<_Tp>(copysign(_Tp(0), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
1290     }
1291     if (isnan(__x.imag()))
1292     {
1293         if (isinf(__x.real()) || __x.real() == 0)
1294             return complex<_Tp>(copysign(_Tp(0), __x.real()), __x.imag());
1295         return complex<_Tp>(__x.imag(), __x.imag());
1296     }
1297     if (isnan(__x.real()))
1298     {
1299         return complex<_Tp>(__x.real(), __x.real());
1300     }
1301     if (isinf(__x.real()))
1302     {
1303         return complex<_Tp>(copysign(_Tp(0), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
1304     }
1305     if (abs(__x.real()) == _Tp(1) && __x.imag() == _Tp(0))
1306     {
1307         return complex<_Tp>(copysign(_Tp(INFINITY), __x.real()), copysign(_Tp(0), __x.imag()));
1308     }
1309     complex<_Tp> __z = log((_Tp(1) + __x) / (_Tp(1) - __x)) / _Tp(2);
1310     return complex<_Tp>(copysign(__z.real(), __x.real()), copysign(__z.imag(), __x.imag()));
1311 }
1312
1313 // sinh
1314
1315 template<class _Tp>
1316 complex<_Tp>
1317 sinh(const complex<_Tp>& __x)
1318 {
1319     if (isinf(__x.real()) && !isfinite(__x.imag()))
1320         return complex<_Tp>(__x.real(), _Tp(NAN));
1321     if (__x.real() == 0 && !isfinite(__x.imag()))
1322         return complex<_Tp>(__x.real(), _Tp(NAN));
1323     if (__x.imag() == 0 && !isfinite(__x.real()))
1324         return __x;
1325     return complex<_Tp>(sinh(__x.real()) * cos(__x.imag()), cosh(__x.real()) * sin(__x.imag()));
1326 }
1327
1328 // cosh
1329
1330 template<class _Tp>
1331 complex<_Tp>
1332 cosh(const complex<_Tp>& __x)
1333 {
1334     if (isinf(__x.real()) && !isfinite(__x.imag()))
1335         return complex<_Tp>(abs(__x.real()), _Tp(NAN));
1336     if (__x.real() == 0 && !isfinite(__x.imag()))
1337         return complex<_Tp>(_Tp(NAN), __x.real());
1338     if (__x.real() == 0 && __x.imag() == 0)
1339         return complex<_Tp>(_Tp(1), __x.imag());
1340     if (__x.imag() == 0 && !isfinite(__x.real()))
1341         return complex<_Tp>(abs(__x.real()), __x.imag());
1342     return complex<_Tp>(cosh(__x.real()) * cos(__x.imag()), sinh(__x.real()) * sin(__x.imag()));
1343 }
1344
1345 // tanh
1346
1347 template<class _Tp>
1348 complex<_Tp>
1349 tanh(const complex<_Tp>& __x)
1350 {
1351     if (isinf(__x.real()))
1352     {
1353         if (!isfinite(__x.imag()))
1354             return complex<_Tp>(_Tp(1), _Tp(0));
1355         return complex<_Tp>(_Tp(1), copysign(_Tp(0), sin(_Tp(2) * __x.imag())));
1356     }
1357     if (isnan(__x.real()) && __x.imag() == 0)
1358         return __x;
1359     _Tp __2r(_Tp(2) * __x.real());
1360     _Tp __2i(_Tp(2) * __x.imag());
1361     _Tp __d(cosh(__2r) + cos(__2i));
1362     _Tp __2rsh(sinh(__2r));
1363     if (isinf(__2rsh) && isinf(__d))
1364         return complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1),
1365                             __2i > _Tp(0) ? _Tp(0) : _Tp(-0.));
1366     return  complex<_Tp>(__2rsh/__d, sin(__2i)/__d);
1367 }
1368
1369 // asin
1370
1371 template<class _Tp>
1372 complex<_Tp>
1373 asin(const complex<_Tp>& __x)
1374 {
1375     complex<_Tp> __z = asinh(complex<_Tp>(-__x.imag(), __x.real()));
1376     return complex<_Tp>(__z.imag(), -__z.real());
1377 }
1378
1379 // acos
1380
1381 template<class _Tp>
1382 complex<_Tp>
1383 acos(const complex<_Tp>& __x)
1384 {
1385     const _Tp __pi(atan2(+0., -0.));
1386     if (isinf(__x.real()))
1387     {
1388         if (isnan(__x.imag()))
1389             return complex<_Tp>(__x.imag(), __x.real());
1390         if (isinf(__x.imag()))
1391         {
1392             if (__x.real() < _Tp(0))
1393                 return complex<_Tp>(_Tp(0.75) * __pi, -__x.imag());
1394             return complex<_Tp>(_Tp(0.25) * __pi, -__x.imag());
1395         }
1396         if (__x.real() < _Tp(0))
1397             return complex<_Tp>(__pi, signbit(__x.imag()) ? -__x.real() : __x.real());
1398         return complex<_Tp>(_Tp(0), signbit(__x.imag()) ? __x.real() : -__x.real());
1399     }
1400     if (isnan(__x.real()))
1401     {
1402         if (isinf(__x.imag()))
1403             return complex<_Tp>(__x.real(), -__x.imag());
1404         return complex<_Tp>(__x.real(), __x.real());
1405     }
1406     if (isinf(__x.imag()))
1407         return complex<_Tp>(__pi/_Tp(2), -__x.imag());
1408     if (__x.real() == 0 && (__x.imag() == 0 || isnan(__x.imag())))
1409         return complex<_Tp>(__pi/_Tp(2), -__x.imag());
1410     complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) - _Tp(1)));
1411     if (signbit(__x.imag()))
1412         return complex<_Tp>(abs(__z.imag()), abs(__z.real()));
1413     return complex<_Tp>(abs(__z.imag()), -abs(__z.real()));
1414 }
1415
1416 // atan
1417
1418 template<class _Tp>
1419 complex<_Tp>
1420 atan(const complex<_Tp>& __x)
1421 {
1422     complex<_Tp> __z = atanh(complex<_Tp>(-__x.imag(), __x.real()));
1423     return complex<_Tp>(__z.imag(), -__z.real());
1424 }
1425
1426 // sin
1427
1428 template<class _Tp>
1429 complex<_Tp>
1430 sin(const complex<_Tp>& __x)
1431 {
1432     complex<_Tp> __z = sinh(complex<_Tp>(-__x.imag(), __x.real()));
1433     return complex<_Tp>(__z.imag(), -__z.real());
1434 }
1435
1436 // cos
1437
1438 template<class _Tp>
1439 inline _LIBCPP_INLINE_VISIBILITY
1440 complex<_Tp>
1441 cos(const complex<_Tp>& __x)
1442 {
1443     return cosh(complex<_Tp>(-__x.imag(), __x.real()));
1444 }
1445
1446 // tan
1447
1448 template<class _Tp>
1449 complex<_Tp>
1450 tan(const complex<_Tp>& __x)
1451 {
1452     complex<_Tp> __z = tanh(complex<_Tp>(-__x.imag(), __x.real()));
1453     return complex<_Tp>(__z.imag(), -__z.real());
1454 }
1455
1456 template<class _Tp, class _CharT, class _Traits>
1457 basic_istream<_CharT, _Traits>&
1458 operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
1459 {
1460     if (__is.good())
1461     {
1462         ws(__is);
1463         if (__is.peek() == _CharT('('))
1464         {
1465             __is.get();
1466             _Tp __r;
1467             __is >> __r;
1468             if (!__is.fail())
1469             {
1470                 ws(__is);
1471                 _CharT __c = __is.peek();
1472                 if (__c == _CharT(','))
1473                 {
1474                     __is.get();
1475                     _Tp __i;
1476                     __is >> __i;
1477                     if (!__is.fail())
1478                     {
1479                         ws(__is);
1480                         __c = __is.peek();
1481                         if (__c == _CharT(')'))
1482                         {
1483                             __is.get();
1484                             __x = complex<_Tp>(__r, __i);
1485                         }
1486                         else
1487                             __is.setstate(ios_base::failbit);
1488                     }
1489                     else
1490                         __is.setstate(ios_base::failbit);
1491                 }
1492                 else if (__c == _CharT(')'))
1493                 {
1494                     __is.get();
1495                     __x = complex<_Tp>(__r, _Tp(0));
1496                 }
1497                 else
1498                     __is.setstate(ios_base::failbit);
1499             }
1500             else
1501                 __is.setstate(ios_base::failbit);
1502         }
1503         else
1504         {
1505             _Tp __r;
1506             __is >> __r;
1507             if (!__is.fail())
1508                 __x = complex<_Tp>(__r, _Tp(0));
1509             else
1510                 __is.setstate(ios_base::failbit);
1511         }
1512     }
1513     else
1514         __is.setstate(ios_base::failbit);
1515     return __is;
1516 }
1517
1518 template<class _Tp, class _CharT, class _Traits>
1519 basic_ostream<_CharT, _Traits>&
1520 operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
1521 {
1522     basic_ostringstream<_CharT, _Traits> __s;
1523     __s.flags(__os.flags());
1524     __s.imbue(__os.getloc());
1525     __s.precision(__os.precision());
1526     __s << '(' << __x.real() << ',' << __x.imag() << ')';
1527     return __os << __s.str();
1528 }
1529
1530 #if _LIBCPP_STD_VER > 11
1531 // Literal suffix for complex number literals [complex.literals]
1532 inline namespace literals
1533 {
1534   inline namespace complex_literals
1535   {
1536     constexpr complex<long double> operator""il(long double __im)
1537     {
1538         return { 0.0l, __im };
1539     }
1540
1541     constexpr complex<long double> operator""il(unsigned long long __im)
1542     {
1543         return { 0.0l, static_cast<long double>(__im) };
1544     }
1545
1546
1547     constexpr complex<double> operator""i(long double __im)
1548     {
1549         return { 0.0, static_cast<double>(__im) };
1550     }
1551
1552     constexpr complex<double> operator""i(unsigned long long __im)
1553     {
1554         return { 0.0, static_cast<double>(__im) };
1555     }
1556
1557
1558     constexpr complex<float> operator""if(long double __im)
1559     {
1560         return { 0.0f, static_cast<float>(__im) };
1561     }
1562
1563     constexpr complex<float> operator""if(unsigned long long __im)
1564     {
1565         return { 0.0f, static_cast<float>(__im) };
1566     }
1567   }
1568 }
1569 #endif
1570
1571 _LIBCPP_END_NAMESPACE_STD
1572
1573 #endif  // _LIBCPP_COMPLEX