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 17namespace std 18{ 19 20template<class T> 21class complex 22{ 23public: 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 50template<> 51class complex<float> 52{ 53public: 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 79template<> 80class complex<double> 81{ 82public: 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 108template<> 109class complex<long double> 110{ 111public: 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: 138template<class T> complex<T> operator+(const complex<T>&, const complex<T>&); 139template<class T> complex<T> operator+(const complex<T>&, const T&); 140template<class T> complex<T> operator+(const T&, const complex<T>&); 141template<class T> complex<T> operator-(const complex<T>&, const complex<T>&); 142template<class T> complex<T> operator-(const complex<T>&, const T&); 143template<class T> complex<T> operator-(const T&, const complex<T>&); 144template<class T> complex<T> operator*(const complex<T>&, const complex<T>&); 145template<class T> complex<T> operator*(const complex<T>&, const T&); 146template<class T> complex<T> operator*(const T&, const complex<T>&); 147template<class T> complex<T> operator/(const complex<T>&, const complex<T>&); 148template<class T> complex<T> operator/(const complex<T>&, const T&); 149template<class T> complex<T> operator/(const T&, const complex<T>&); 150template<class T> complex<T> operator+(const complex<T>&); 151template<class T> complex<T> operator-(const complex<T>&); 152template<class T> bool operator==(const complex<T>&, const complex<T>&); // constexpr in C++14 153template<class T> bool operator==(const complex<T>&, const T&); // constexpr in C++14 154template<class T> bool operator==(const T&, const complex<T>&); // constexpr in C++14 155template<class T> bool operator!=(const complex<T>&, const complex<T>&); // constexpr in C++14 156template<class T> bool operator!=(const complex<T>&, const T&); // constexpr in C++14 157template<class T> bool operator!=(const T&, const complex<T>&); // constexpr in C++14 158 159template<class T, class charT, class traits> 160 basic_istream<charT, traits>& 161 operator>>(basic_istream<charT, traits>&, complex<T>&); 162template<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 168template<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 171template<Integral T> double real(T); // constexpr in C++14 172 float real(float); // constexpr in C++14 173 174template<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 177template<Integral T> double imag(T); // constexpr in C++14 178 float imag(float); // constexpr in C++14 179 180template<class T> T abs(const complex<T>&); 181 182template<class T> T arg(const complex<T>&); 183 long double arg(long double); 184 double arg(double); 185template<Integral T> double arg(T); 186 float arg(float); 187 188template<class T> T norm(const complex<T>&); 189 long double norm(long double); 190 double norm(double); 191template<Integral T> double norm(T); 192 float norm(float); 193 194template<class T> complex<T> conj(const complex<T>&); 195 complex<long double> conj(long double); 196 complex<double> conj(double); 197template<Integral T> complex<double> conj(T); 198 complex<float> conj(float); 199 200template<class T> complex<T> proj(const complex<T>&); 201 complex<long double> proj(long double); 202 complex<double> proj(double); 203template<Integral T> complex<double> proj(T); 204 complex<float> proj(float); 205 206template<class T> complex<T> polar(const T&, const T& = T()); 207 208// 26.3.8 transcendentals: 209template<class T> complex<T> acos(const complex<T>&); 210template<class T> complex<T> asin(const complex<T>&); 211template<class T> complex<T> atan(const complex<T>&); 212template<class T> complex<T> acosh(const complex<T>&); 213template<class T> complex<T> asinh(const complex<T>&); 214template<class T> complex<T> atanh(const complex<T>&); 215template<class T> complex<T> cos (const complex<T>&); 216template<class T> complex<T> cosh (const complex<T>&); 217template<class T> complex<T> exp (const complex<T>&); 218template<class T> complex<T> log (const complex<T>&); 219template<class T> complex<T> log10(const complex<T>&); 220 221template<class T> complex<T> pow(const complex<T>&, const T&); 222template<class T> complex<T> pow(const complex<T>&, const complex<T>&); 223template<class T> complex<T> pow(const T&, const complex<T>&); 224 225template<class T> complex<T> sin (const complex<T>&); 226template<class T> complex<T> sinh (const complex<T>&); 227template<class T> complex<T> sqrt (const complex<T>&); 228template<class T> complex<T> tan (const complex<T>&); 229template<class T> complex<T> tanh (const complex<T>&); 230 231template<class T, class charT, class traits> 232 basic_istream<charT, traits>& 233 operator>>(basic_istream<charT, traits>& is, complex<T>& x); 234 235template<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 256template<class _Tp> class _LIBCPP_TEMPLATE_VIS complex; 257 258template<class _Tp> complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w); 259template<class _Tp> complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y); 260 261template<class _Tp> 262class _LIBCPP_TEMPLATE_VIS complex 263{ 264public: 265 typedef _Tp value_type; 266private: 267 value_type __re_; 268 value_type __im_; 269public: 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 320template<> class _LIBCPP_TEMPLATE_VIS complex<double>; 321template<> class _LIBCPP_TEMPLATE_VIS complex<long double>; 322 323template<> 324class _LIBCPP_TEMPLATE_VIS complex<float> 325{ 326 float __re_; 327 float __im_; 328public: 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 381template<> 382class _LIBCPP_TEMPLATE_VIS complex<double> 383{ 384 double __re_; 385 double __im_; 386public: 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 439template<> 440class _LIBCPP_TEMPLATE_VIS complex<long double> 441{ 442 long double __re_; 443 long double __im_; 444public: 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 497inline 498_LIBCPP_CONSTEXPR 499complex<float>::complex(const complex<double>& __c) 500 : __re_(__c.real()), __im_(__c.imag()) {} 501 502inline 503_LIBCPP_CONSTEXPR 504complex<float>::complex(const complex<long double>& __c) 505 : __re_(__c.real()), __im_(__c.imag()) {} 506 507inline 508_LIBCPP_CONSTEXPR 509complex<double>::complex(const complex<float>& __c) 510 : __re_(__c.real()), __im_(__c.imag()) {} 511 512inline 513_LIBCPP_CONSTEXPR 514complex<double>::complex(const complex<long double>& __c) 515 : __re_(__c.real()), __im_(__c.imag()) {} 516 517inline 518_LIBCPP_CONSTEXPR 519complex<long double>::complex(const complex<float>& __c) 520 : __re_(__c.real()), __im_(__c.imag()) {} 521 522inline 523_LIBCPP_CONSTEXPR 524complex<long double>::complex(const complex<double>& __c) 525 : __re_(__c.real()), __im_(__c.imag()) {} 526 527// 26.3.6 operators: 528 529template<class _Tp> 530inline _LIBCPP_INLINE_VISIBILITY 531complex<_Tp> 532operator+(const complex<_Tp>& __x, const complex<_Tp>& __y) 533{ 534 complex<_Tp> __t(__x); 535 __t += __y; 536 return __t; 537} 538 539template<class _Tp> 540inline _LIBCPP_INLINE_VISIBILITY 541complex<_Tp> 542operator+(const complex<_Tp>& __x, const _Tp& __y) 543{ 544 complex<_Tp> __t(__x); 545 __t += __y; 546 return __t; 547} 548 549template<class _Tp> 550inline _LIBCPP_INLINE_VISIBILITY 551complex<_Tp> 552operator+(const _Tp& __x, const complex<_Tp>& __y) 553{ 554 complex<_Tp> __t(__y); 555 __t += __x; 556 return __t; 557} 558 559template<class _Tp> 560inline _LIBCPP_INLINE_VISIBILITY 561complex<_Tp> 562operator-(const complex<_Tp>& __x, const complex<_Tp>& __y) 563{ 564 complex<_Tp> __t(__x); 565 __t -= __y; 566 return __t; 567} 568 569template<class _Tp> 570inline _LIBCPP_INLINE_VISIBILITY 571complex<_Tp> 572operator-(const complex<_Tp>& __x, const _Tp& __y) 573{ 574 complex<_Tp> __t(__x); 575 __t -= __y; 576 return __t; 577} 578 579template<class _Tp> 580inline _LIBCPP_INLINE_VISIBILITY 581complex<_Tp> 582operator-(const _Tp& __x, const complex<_Tp>& __y) 583{ 584 complex<_Tp> __t(-__y); 585 __t += __x; 586 return __t; 587} 588 589template<class _Tp> 590complex<_Tp> 591operator*(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 648template<class _Tp> 649inline _LIBCPP_INLINE_VISIBILITY 650complex<_Tp> 651operator*(const complex<_Tp>& __x, const _Tp& __y) 652{ 653 complex<_Tp> __t(__x); 654 __t *= __y; 655 return __t; 656} 657 658template<class _Tp> 659inline _LIBCPP_INLINE_VISIBILITY 660complex<_Tp> 661operator*(const _Tp& __x, const complex<_Tp>& __y) 662{ 663 complex<_Tp> __t(__y); 664 __t *= __x; 665 return __t; 666} 667 668template<class _Tp> 669complex<_Tp> 670operator/(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 712template<class _Tp> 713inline _LIBCPP_INLINE_VISIBILITY 714complex<_Tp> 715operator/(const complex<_Tp>& __x, const _Tp& __y) 716{ 717 return complex<_Tp>(__x.real() / __y, __x.imag() / __y); 718} 719 720template<class _Tp> 721inline _LIBCPP_INLINE_VISIBILITY 722complex<_Tp> 723operator/(const _Tp& __x, const complex<_Tp>& __y) 724{ 725 complex<_Tp> __t(__x); 726 __t /= __y; 727 return __t; 728} 729 730template<class _Tp> 731inline _LIBCPP_INLINE_VISIBILITY 732complex<_Tp> 733operator+(const complex<_Tp>& __x) 734{ 735 return __x; 736} 737 738template<class _Tp> 739inline _LIBCPP_INLINE_VISIBILITY 740complex<_Tp> 741operator-(const complex<_Tp>& __x) 742{ 743 return complex<_Tp>(-__x.real(), -__x.imag()); 744} 745 746template<class _Tp> 747inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 748bool 749operator==(const complex<_Tp>& __x, const complex<_Tp>& __y) 750{ 751 return __x.real() == __y.real() && __x.imag() == __y.imag(); 752} 753 754template<class _Tp> 755inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 756bool 757operator==(const complex<_Tp>& __x, const _Tp& __y) 758{ 759 return __x.real() == __y && __x.imag() == 0; 760} 761 762template<class _Tp> 763inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 764bool 765operator==(const _Tp& __x, const complex<_Tp>& __y) 766{ 767 return __x == __y.real() && 0 == __y.imag(); 768} 769 770template<class _Tp> 771inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 772bool 773operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y) 774{ 775 return !(__x == __y); 776} 777 778template<class _Tp> 779inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 780bool 781operator!=(const complex<_Tp>& __x, const _Tp& __y) 782{ 783 return !(__x == __y); 784} 785 786template<class _Tp> 787inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 788bool 789operator!=(const _Tp& __x, const complex<_Tp>& __y) 790{ 791 return !(__x == __y); 792} 793 794// 26.3.7 values: 795 796template <class _Tp, bool = is_integral<_Tp>::value, 797 bool = is_floating_point<_Tp>::value 798 > 799struct __libcpp_complex_overload_traits {}; 800 801// Integral Types 802template <class _Tp> 803struct __libcpp_complex_overload_traits<_Tp, true, false> 804{ 805 typedef double _ValueType; 806 typedef complex<double> _ComplexType; 807}; 808 809// Floating point types 810template <class _Tp> 811struct __libcpp_complex_overload_traits<_Tp, false, true> 812{ 813 typedef _Tp _ValueType; 814 typedef complex<_Tp> _ComplexType; 815}; 816 817// real 818 819template<class _Tp> 820inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 821_Tp 822real(const complex<_Tp>& __c) 823{ 824 return __c.real(); 825} 826 827template <class _Tp> 828inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 829typename __libcpp_complex_overload_traits<_Tp>::_ValueType 830real(_Tp __re) 831{ 832 return __re; 833} 834 835// imag 836 837template<class _Tp> 838inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 839_Tp 840imag(const complex<_Tp>& __c) 841{ 842 return __c.imag(); 843} 844 845template <class _Tp> 846inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 847typename __libcpp_complex_overload_traits<_Tp>::_ValueType 848imag(_Tp) 849{ 850 return 0; 851} 852 853// abs 854 855template<class _Tp> 856inline _LIBCPP_INLINE_VISIBILITY 857_Tp 858abs(const complex<_Tp>& __c) 859{ 860 return hypot(__c.real(), __c.imag()); 861} 862 863// arg 864 865template<class _Tp> 866inline _LIBCPP_INLINE_VISIBILITY 867_Tp 868arg(const complex<_Tp>& __c) 869{ 870 return atan2(__c.imag(), __c.real()); 871} 872 873template <class _Tp> 874inline _LIBCPP_INLINE_VISIBILITY 875typename enable_if< 876 is_same<_Tp, long double>::value, 877 long double 878>::type 879arg(_Tp __re) 880{ 881 return atan2l(0.L, __re); 882} 883 884template<class _Tp> 885inline _LIBCPP_INLINE_VISIBILITY 886typename enable_if 887< 888 is_integral<_Tp>::value || is_same<_Tp, double>::value, 889 double 890>::type 891arg(_Tp __re) 892{ 893 return atan2(0., __re); 894} 895 896template <class _Tp> 897inline _LIBCPP_INLINE_VISIBILITY 898typename enable_if< 899 is_same<_Tp, float>::value, 900 float 901>::type 902arg(_Tp __re) 903{ 904 return atan2f(0.F, __re); 905} 906 907// norm 908 909template<class _Tp> 910inline _LIBCPP_INLINE_VISIBILITY 911_Tp 912norm(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 921template <class _Tp> 922inline _LIBCPP_INLINE_VISIBILITY 923typename __libcpp_complex_overload_traits<_Tp>::_ValueType 924norm(_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 932template<class _Tp> 933inline _LIBCPP_INLINE_VISIBILITY 934complex<_Tp> 935conj(const complex<_Tp>& __c) 936{ 937 return complex<_Tp>(__c.real(), -__c.imag()); 938} 939 940template <class _Tp> 941inline _LIBCPP_INLINE_VISIBILITY 942typename __libcpp_complex_overload_traits<_Tp>::_ComplexType 943conj(_Tp __re) 944{ 945 typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType; 946 return _ComplexType(__re); 947} 948 949 950 951// proj 952 953template<class _Tp> 954inline _LIBCPP_INLINE_VISIBILITY 955complex<_Tp> 956proj(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 964template <class _Tp> 965inline _LIBCPP_INLINE_VISIBILITY 966typename enable_if 967< 968 is_floating_point<_Tp>::value, 969 typename __libcpp_complex_overload_traits<_Tp>::_ComplexType 970>::type 971proj(_Tp __re) 972{ 973 if (__libcpp_isinf_or_builtin(__re)) 974 __re = abs(__re); 975 return complex<_Tp>(__re); 976} 977 978template <class _Tp> 979inline _LIBCPP_INLINE_VISIBILITY 980typename enable_if 981< 982 is_integral<_Tp>::value, 983 typename __libcpp_complex_overload_traits<_Tp>::_ComplexType 984>::type 985proj(_Tp __re) 986{ 987 typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType; 988 return _ComplexType(__re); 989} 990 991// polar 992 993template<class _Tp> 994complex<_Tp> 995polar(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 1022template<class _Tp> 1023inline _LIBCPP_INLINE_VISIBILITY 1024complex<_Tp> 1025log(const complex<_Tp>& __x) 1026{ 1027 return complex<_Tp>(log(abs(__x)), arg(__x)); 1028} 1029 1030// log10 1031 1032template<class _Tp> 1033inline _LIBCPP_INLINE_VISIBILITY 1034complex<_Tp> 1035log10(const complex<_Tp>& __x) 1036{ 1037 return log(__x) / log(_Tp(10)); 1038} 1039 1040// sqrt 1041 1042template<class _Tp> 1043complex<_Tp> 1044sqrt(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 1059template<class _Tp> 1060complex<_Tp> 1061exp(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 1086template<class _Tp> 1087inline _LIBCPP_INLINE_VISIBILITY 1088complex<_Tp> 1089pow(const complex<_Tp>& __x, const complex<_Tp>& __y) 1090{ 1091 return exp(__y * log(__x)); 1092} 1093 1094template<class _Tp, class _Up> 1095inline _LIBCPP_INLINE_VISIBILITY 1096complex<typename __promote<_Tp, _Up>::type> 1097pow(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 1103template<class _Tp, class _Up> 1104inline _LIBCPP_INLINE_VISIBILITY 1105typename enable_if 1106< 1107 is_arithmetic<_Up>::value, 1108 complex<typename __promote<_Tp, _Up>::type> 1109>::type 1110pow(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 1116template<class _Tp, class _Up> 1117inline _LIBCPP_INLINE_VISIBILITY 1118typename enable_if 1119< 1120 is_arithmetic<_Tp>::value, 1121 complex<typename __promote<_Tp, _Up>::type> 1122>::type 1123pow(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 1131template<class _Tp> 1132inline _LIBCPP_INLINE_VISIBILITY 1133complex<_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 1142template<class _Tp> 1143complex<_Tp> 1144asinh(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 1171template<class _Tp> 1172complex<_Tp> 1173acosh(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 1205template<class _Tp> 1206complex<_Tp> 1207atanh(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 1238template<class _Tp> 1239complex<_Tp> 1240sinh(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 1253template<class _Tp> 1254complex<_Tp> 1255cosh(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 1270template<class _Tp> 1271complex<_Tp> 1272tanh(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 1294template<class _Tp> 1295complex<_Tp> 1296asin(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 1304template<class _Tp> 1305complex<_Tp> 1306acos(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 1341template<class _Tp> 1342complex<_Tp> 1343atan(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 1351template<class _Tp> 1352complex<_Tp> 1353sin(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 1361template<class _Tp> 1362inline _LIBCPP_INLINE_VISIBILITY 1363complex<_Tp> 1364cos(const complex<_Tp>& __x) 1365{ 1366 return cosh(complex<_Tp>(-__x.imag(), __x.real())); 1367} 1368 1369// tan 1370 1371template<class _Tp> 1372complex<_Tp> 1373tan(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 1379template<class _Tp, class _CharT, class _Traits> 1380basic_istream<_CharT, _Traits>& 1381operator>>(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 1441template<class _Tp, class _CharT, class _Traits> 1442basic_ostream<_CharT, _Traits>& 1443operator<<(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] 1455inline 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 1497