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