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