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