1// The template and inlines for the -*- C++ -*- complex number classes. 2 3// Copyright (C) 1997-2019 Free Software Foundation, Inc. 4// 5// This file is part of the GNU ISO C++ Library. This library is free 6// software; you can redistribute it and/or modify it under the 7// terms of the GNU General Public License as published by the 8// Free Software Foundation; either version 3, or (at your option) 9// any later version. 10 11// This library is distributed in the hope that it will be useful, 12// but WITHOUT ANY WARRANTY; without even the implied warranty of 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14// GNU General Public License for more details. 15 16// Under Section 7 of GPL version 3, you are granted additional 17// permissions described in the GCC Runtime Library Exception, version 18// 3.1, as published by the Free Software Foundation. 19 20// You should have received a copy of the GNU General Public License and 21// a copy of the GCC Runtime Library Exception along with this program; 22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23// <http://www.gnu.org/licenses/>. 24 25/** @file include/complex 26 * This is a Standard C++ Library header. 27 */ 28 29// 30// ISO C++ 14882: 26.2 Complex Numbers 31// Note: this is not a conforming implementation. 32// Initially implemented by Ulrich Drepper <drepper@cygnus.com> 33// Improved by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> 34// 35 36#ifndef _GLIBCXX_COMPLEX 37#define _GLIBCXX_COMPLEX 1 38 39#pragma GCC system_header 40 41#include <bits/c++config.h> 42#include <bits/cpp_type_traits.h> 43#include <ext/type_traits.h> 44#include <cmath> 45#include <sstream> 46 47// Get rid of a macro possibly defined in <complex.h> 48#undef complex 49 50#if __cplusplus > 201703L 51# define __cpp_lib_constexpr_complex 201711L 52#endif 53 54namespace std _GLIBCXX_VISIBILITY(default) 55{ 56_GLIBCXX_BEGIN_NAMESPACE_VERSION 57 58 /** 59 * @defgroup complex_numbers Complex Numbers 60 * @ingroup numerics 61 * 62 * Classes and functions for complex numbers. 63 * @{ 64 */ 65 66 // Forward declarations. 67 template<typename _Tp> class complex; 68 template<> class complex<float>; 69 template<> class complex<double>; 70 template<> class complex<long double>; 71 72 /// Return magnitude of @a z. 73 template<typename _Tp> _Tp abs(const complex<_Tp>&); 74 /// Return phase angle of @a z. 75 template<typename _Tp> _Tp arg(const complex<_Tp>&); 76 /// Return @a z magnitude squared. 77 template<typename _Tp> _Tp _GLIBCXX20_CONSTEXPR norm(const complex<_Tp>&); 78 79 /// Return complex conjugate of @a z. 80 template<typename _Tp> 81 _GLIBCXX20_CONSTEXPR complex<_Tp> conj(const complex<_Tp>&); 82 /// Return complex with magnitude @a rho and angle @a theta. 83 template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0); 84 85 // Transcendentals: 86 /// Return complex cosine of @a z. 87 template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&); 88 /// Return complex hyperbolic cosine of @a z. 89 template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&); 90 /// Return complex base e exponential of @a z. 91 template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&); 92 /// Return complex natural logarithm of @a z. 93 template<typename _Tp> complex<_Tp> log(const complex<_Tp>&); 94 /// Return complex base 10 logarithm of @a z. 95 template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&); 96 /// Return @a x to the @a y'th power. 97 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int); 98 /// Return @a x to the @a y'th power. 99 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&); 100 /// Return @a x to the @a y'th power. 101 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, 102 const complex<_Tp>&); 103 /// Return @a x to the @a y'th power. 104 template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&); 105 /// Return complex sine of @a z. 106 template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&); 107 /// Return complex hyperbolic sine of @a z. 108 template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&); 109 /// Return complex square root of @a z. 110 template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&); 111 /// Return complex tangent of @a z. 112 template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&); 113 /// Return complex hyperbolic tangent of @a z. 114 template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&); 115 116 117 // 26.2.2 Primary template class complex 118 /** 119 * Template to represent complex numbers. 120 * 121 * Specializations for float, double, and long double are part of the 122 * library. Results with any other type are not guaranteed. 123 * 124 * @param Tp Type of real and imaginary values. 125 */ 126 template<typename _Tp> 127 struct complex 128 { 129 /// Value typedef. 130 typedef _Tp value_type; 131 132 /// Default constructor. First parameter is x, second parameter is y. 133 /// Unspecified parameters default to 0. 134 _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp()) 135 : _M_real(__r), _M_imag(__i) { } 136 137 // Let the compiler synthesize the copy constructor 138#if __cplusplus >= 201103L 139 constexpr complex(const complex&) = default; 140#endif 141 142 /// Converting constructor. 143 template<typename _Up> 144 _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z) 145 : _M_real(__z.real()), _M_imag(__z.imag()) { } 146 147#if __cplusplus >= 201103L 148 // _GLIBCXX_RESOLVE_LIB_DEFECTS 149 // DR 387. std::complex over-encapsulated. 150 _GLIBCXX_ABI_TAG_CXX11 151 constexpr _Tp 152 real() const { return _M_real; } 153 154 _GLIBCXX_ABI_TAG_CXX11 155 constexpr _Tp 156 imag() const { return _M_imag; } 157#else 158 /// Return real part of complex number. 159 _Tp& 160 real() { return _M_real; } 161 162 /// Return real part of complex number. 163 const _Tp& 164 real() const { return _M_real; } 165 166 /// Return imaginary part of complex number. 167 _Tp& 168 imag() { return _M_imag; } 169 170 /// Return imaginary part of complex number. 171 const _Tp& 172 imag() const { return _M_imag; } 173#endif 174 175 // _GLIBCXX_RESOLVE_LIB_DEFECTS 176 // DR 387. std::complex over-encapsulated. 177 _GLIBCXX20_CONSTEXPR void 178 real(_Tp __val) { _M_real = __val; } 179 180 _GLIBCXX20_CONSTEXPR void 181 imag(_Tp __val) { _M_imag = __val; } 182 183 /// Assign a scalar to this complex number. 184 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator=(const _Tp&); 185 186 /// Add a scalar to this complex number. 187 // 26.2.5/1 188 _GLIBCXX20_CONSTEXPR complex<_Tp>& 189 operator+=(const _Tp& __t) 190 { 191 _M_real += __t; 192 return *this; 193 } 194 195 /// Subtract a scalar from this complex number. 196 // 26.2.5/3 197 _GLIBCXX20_CONSTEXPR complex<_Tp>& 198 operator-=(const _Tp& __t) 199 { 200 _M_real -= __t; 201 return *this; 202 } 203 204 /// Multiply this complex number by a scalar. 205 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator*=(const _Tp&); 206 /// Divide this complex number by a scalar. 207 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator/=(const _Tp&); 208 209 // Let the compiler synthesize the copy assignment operator 210#if __cplusplus >= 201103L 211 _GLIBCXX20_CONSTEXPR complex& operator=(const complex&) = default; 212#endif 213 214 /// Assign another complex number to this one. 215 template<typename _Up> 216 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator=(const complex<_Up>&); 217 /// Add another complex number to this one. 218 template<typename _Up> 219 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator+=(const complex<_Up>&); 220 /// Subtract another complex number from this one. 221 template<typename _Up> 222 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator-=(const complex<_Up>&); 223 /// Multiply this complex number by another. 224 template<typename _Up> 225 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator*=(const complex<_Up>&); 226 /// Divide this complex number by another. 227 template<typename _Up> 228 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator/=(const complex<_Up>&); 229 230 _GLIBCXX_CONSTEXPR complex __rep() const 231 { return *this; } 232 233 private: 234 _Tp _M_real; 235 _Tp _M_imag; 236 }; 237 238 template<typename _Tp> 239 _GLIBCXX20_CONSTEXPR complex<_Tp>& 240 complex<_Tp>::operator=(const _Tp& __t) 241 { 242 _M_real = __t; 243 _M_imag = _Tp(); 244 return *this; 245 } 246 247 // 26.2.5/5 248 template<typename _Tp> 249 _GLIBCXX20_CONSTEXPR complex<_Tp>& 250 complex<_Tp>::operator*=(const _Tp& __t) 251 { 252 _M_real *= __t; 253 _M_imag *= __t; 254 return *this; 255 } 256 257 // 26.2.5/7 258 template<typename _Tp> 259 _GLIBCXX20_CONSTEXPR complex<_Tp>& 260 complex<_Tp>::operator/=(const _Tp& __t) 261 { 262 _M_real /= __t; 263 _M_imag /= __t; 264 return *this; 265 } 266 267 template<typename _Tp> 268 template<typename _Up> 269 _GLIBCXX20_CONSTEXPR complex<_Tp>& 270 complex<_Tp>::operator=(const complex<_Up>& __z) 271 { 272 _M_real = __z.real(); 273 _M_imag = __z.imag(); 274 return *this; 275 } 276 277 // 26.2.5/9 278 template<typename _Tp> 279 template<typename _Up> 280 _GLIBCXX20_CONSTEXPR complex<_Tp>& 281 complex<_Tp>::operator+=(const complex<_Up>& __z) 282 { 283 _M_real += __z.real(); 284 _M_imag += __z.imag(); 285 return *this; 286 } 287 288 // 26.2.5/11 289 template<typename _Tp> 290 template<typename _Up> 291 _GLIBCXX20_CONSTEXPR complex<_Tp>& 292 complex<_Tp>::operator-=(const complex<_Up>& __z) 293 { 294 _M_real -= __z.real(); 295 _M_imag -= __z.imag(); 296 return *this; 297 } 298 299 // 26.2.5/13 300 // XXX: This is a grammar school implementation. 301 template<typename _Tp> 302 template<typename _Up> 303 _GLIBCXX20_CONSTEXPR complex<_Tp>& 304 complex<_Tp>::operator*=(const complex<_Up>& __z) 305 { 306 const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag(); 307 _M_imag = _M_real * __z.imag() + _M_imag * __z.real(); 308 _M_real = __r; 309 return *this; 310 } 311 312 // 26.2.5/15 313 // XXX: This is a grammar school implementation. 314 template<typename _Tp> 315 template<typename _Up> 316 _GLIBCXX20_CONSTEXPR complex<_Tp>& 317 complex<_Tp>::operator/=(const complex<_Up>& __z) 318 { 319 const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag(); 320 const _Tp __n = std::norm(__z); 321 _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n; 322 _M_real = __r / __n; 323 return *this; 324 } 325 326 // Operators: 327 ///@{ 328 /// Return new complex value @a x plus @a y. 329 template<typename _Tp> 330 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 331 operator+(const complex<_Tp>& __x, const complex<_Tp>& __y) 332 { 333 complex<_Tp> __r = __x; 334 __r += __y; 335 return __r; 336 } 337 338 template<typename _Tp> 339 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 340 operator+(const complex<_Tp>& __x, const _Tp& __y) 341 { 342 complex<_Tp> __r = __x; 343 __r += __y; 344 return __r; 345 } 346 347 template<typename _Tp> 348 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 349 operator+(const _Tp& __x, const complex<_Tp>& __y) 350 { 351 complex<_Tp> __r = __y; 352 __r += __x; 353 return __r; 354 } 355 ///@} 356 357 ///@{ 358 /// Return new complex value @a x minus @a y. 359 template<typename _Tp> 360 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 361 operator-(const complex<_Tp>& __x, const complex<_Tp>& __y) 362 { 363 complex<_Tp> __r = __x; 364 __r -= __y; 365 return __r; 366 } 367 368 template<typename _Tp> 369 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 370 operator-(const complex<_Tp>& __x, const _Tp& __y) 371 { 372 complex<_Tp> __r = __x; 373 __r -= __y; 374 return __r; 375 } 376 377 template<typename _Tp> 378 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 379 operator-(const _Tp& __x, const complex<_Tp>& __y) 380 { 381 complex<_Tp> __r = -__y; 382 __r += __x; 383 return __r; 384 } 385 ///@} 386 387 ///@{ 388 /// Return new complex value @a x times @a y. 389 template<typename _Tp> 390 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 391 operator*(const complex<_Tp>& __x, const complex<_Tp>& __y) 392 { 393 complex<_Tp> __r = __x; 394 __r *= __y; 395 return __r; 396 } 397 398 template<typename _Tp> 399 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 400 operator*(const complex<_Tp>& __x, const _Tp& __y) 401 { 402 complex<_Tp> __r = __x; 403 __r *= __y; 404 return __r; 405 } 406 407 template<typename _Tp> 408 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 409 operator*(const _Tp& __x, const complex<_Tp>& __y) 410 { 411 complex<_Tp> __r = __y; 412 __r *= __x; 413 return __r; 414 } 415 ///@} 416 417 ///@{ 418 /// Return new complex value @a x divided by @a y. 419 template<typename _Tp> 420 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 421 operator/(const complex<_Tp>& __x, const complex<_Tp>& __y) 422 { 423 complex<_Tp> __r = __x; 424 __r /= __y; 425 return __r; 426 } 427 428 template<typename _Tp> 429 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 430 operator/(const complex<_Tp>& __x, const _Tp& __y) 431 { 432 complex<_Tp> __r = __x; 433 __r /= __y; 434 return __r; 435 } 436 437 template<typename _Tp> 438 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 439 operator/(const _Tp& __x, const complex<_Tp>& __y) 440 { 441 complex<_Tp> __r = __x; 442 __r /= __y; 443 return __r; 444 } 445 ///@} 446 447 /// Return @a x. 448 template<typename _Tp> 449 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 450 operator+(const complex<_Tp>& __x) 451 { return __x; } 452 453 /// Return complex negation of @a x. 454 template<typename _Tp> 455 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 456 operator-(const complex<_Tp>& __x) 457 { return complex<_Tp>(-__x.real(), -__x.imag()); } 458 459 ///@{ 460 /// Return true if @a x is equal to @a y. 461 template<typename _Tp> 462 inline _GLIBCXX_CONSTEXPR bool 463 operator==(const complex<_Tp>& __x, const complex<_Tp>& __y) 464 { return __x.real() == __y.real() && __x.imag() == __y.imag(); } 465 466 template<typename _Tp> 467 inline _GLIBCXX_CONSTEXPR bool 468 operator==(const complex<_Tp>& __x, const _Tp& __y) 469 { return __x.real() == __y && __x.imag() == _Tp(); } 470 471 template<typename _Tp> 472 inline _GLIBCXX_CONSTEXPR bool 473 operator==(const _Tp& __x, const complex<_Tp>& __y) 474 { return __x == __y.real() && _Tp() == __y.imag(); } 475 ///@} 476 477 ///@{ 478 /// Return false if @a x is equal to @a y. 479 template<typename _Tp> 480 inline _GLIBCXX_CONSTEXPR bool 481 operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y) 482 { return __x.real() != __y.real() || __x.imag() != __y.imag(); } 483 484 template<typename _Tp> 485 inline _GLIBCXX_CONSTEXPR bool 486 operator!=(const complex<_Tp>& __x, const _Tp& __y) 487 { return __x.real() != __y || __x.imag() != _Tp(); } 488 489 template<typename _Tp> 490 inline _GLIBCXX_CONSTEXPR bool 491 operator!=(const _Tp& __x, const complex<_Tp>& __y) 492 { return __x != __y.real() || _Tp() != __y.imag(); } 493 ///@} 494 495 /// Extraction operator for complex values. 496 template<typename _Tp, typename _CharT, class _Traits> 497 basic_istream<_CharT, _Traits>& 498 operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x) 499 { 500 bool __fail = true; 501 _CharT __ch; 502 if (__is >> __ch) 503 { 504 if (_Traits::eq(__ch, __is.widen('('))) 505 { 506 _Tp __u; 507 if (__is >> __u >> __ch) 508 { 509 const _CharT __rparen = __is.widen(')'); 510 if (_Traits::eq(__ch, __rparen)) 511 { 512 __x = __u; 513 __fail = false; 514 } 515 else if (_Traits::eq(__ch, __is.widen(','))) 516 { 517 _Tp __v; 518 if (__is >> __v >> __ch) 519 { 520 if (_Traits::eq(__ch, __rparen)) 521 { 522 __x = complex<_Tp>(__u, __v); 523 __fail = false; 524 } 525 else 526 __is.putback(__ch); 527 } 528 } 529 else 530 __is.putback(__ch); 531 } 532 } 533 else 534 { 535 __is.putback(__ch); 536 _Tp __u; 537 if (__is >> __u) 538 { 539 __x = __u; 540 __fail = false; 541 } 542 } 543 } 544 if (__fail) 545 __is.setstate(ios_base::failbit); 546 return __is; 547 } 548 549 /// Insertion operator for complex values. 550 template<typename _Tp, typename _CharT, class _Traits> 551 basic_ostream<_CharT, _Traits>& 552 operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x) 553 { 554 basic_ostringstream<_CharT, _Traits> __s; 555 __s.flags(__os.flags()); 556 __s.imbue(__os.getloc()); 557 __s.precision(__os.precision()); 558 __s << '(' << __x.real() << ',' << __x.imag() << ')'; 559 return __os << __s.str(); 560 } 561 562 // Values 563#if __cplusplus >= 201103L 564 template<typename _Tp> 565 constexpr _Tp 566 real(const complex<_Tp>& __z) 567 { return __z.real(); } 568 569 template<typename _Tp> 570 constexpr _Tp 571 imag(const complex<_Tp>& __z) 572 { return __z.imag(); } 573#else 574 template<typename _Tp> 575 inline _Tp& 576 real(complex<_Tp>& __z) 577 { return __z.real(); } 578 579 template<typename _Tp> 580 inline const _Tp& 581 real(const complex<_Tp>& __z) 582 { return __z.real(); } 583 584 template<typename _Tp> 585 inline _Tp& 586 imag(complex<_Tp>& __z) 587 { return __z.imag(); } 588 589 template<typename _Tp> 590 inline const _Tp& 591 imag(const complex<_Tp>& __z) 592 { return __z.imag(); } 593#endif 594 595 // 26.2.7/3 abs(__z): Returns the magnitude of __z. 596 template<typename _Tp> 597 inline _Tp 598 __complex_abs(const complex<_Tp>& __z) 599 { 600 _Tp __x = __z.real(); 601 _Tp __y = __z.imag(); 602 const _Tp __s = std::max(abs(__x), abs(__y)); 603 if (__s == _Tp()) // well ... 604 return __s; 605 __x /= __s; 606 __y /= __s; 607 return __s * sqrt(__x * __x + __y * __y); 608 } 609 610#if _GLIBCXX_USE_C99_COMPLEX 611 inline float 612 __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); } 613 614 inline double 615 __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); } 616 617 inline long double 618 __complex_abs(const __complex__ long double& __z) 619 { return __builtin_cabsl(__z); } 620 621 template<typename _Tp> 622 inline _Tp 623 abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); } 624#else 625 template<typename _Tp> 626 inline _Tp 627 abs(const complex<_Tp>& __z) { return __complex_abs(__z); } 628#endif 629 630 631 // 26.2.7/4: arg(__z): Returns the phase angle of __z. 632 template<typename _Tp> 633 inline _Tp 634 __complex_arg(const complex<_Tp>& __z) 635 { return atan2(__z.imag(), __z.real()); } 636 637#if _GLIBCXX_USE_C99_COMPLEX 638 inline float 639 __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); } 640 641 inline double 642 __complex_arg(__complex__ double __z) { return __builtin_carg(__z); } 643 644 inline long double 645 __complex_arg(const __complex__ long double& __z) 646 { return __builtin_cargl(__z); } 647 648 template<typename _Tp> 649 inline _Tp 650 arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); } 651#else 652 template<typename _Tp> 653 inline _Tp 654 arg(const complex<_Tp>& __z) { return __complex_arg(__z); } 655#endif 656 657 // 26.2.7/5: norm(__z) returns the squared magnitude of __z. 658 // As defined, norm() is -not- a norm is the common mathematical 659 // sense used in numerics. The helper class _Norm_helper<> tries to 660 // distinguish between builtin floating point and the rest, so as 661 // to deliver an answer as close as possible to the real value. 662 template<bool> 663 struct _Norm_helper 664 { 665 template<typename _Tp> 666 static inline _GLIBCXX20_CONSTEXPR _Tp _S_do_it(const complex<_Tp>& __z) 667 { 668 const _Tp __x = __z.real(); 669 const _Tp __y = __z.imag(); 670 return __x * __x + __y * __y; 671 } 672 }; 673 674 template<> 675 struct _Norm_helper<true> 676 { 677 template<typename _Tp> 678 static inline _GLIBCXX20_CONSTEXPR _Tp _S_do_it(const complex<_Tp>& __z) 679 { 680 //_Tp __res = std::abs(__z); 681 //return __res * __res; 682 const _Tp __x = __z.real(); 683 const _Tp __y = __z.imag(); 684 return __x * __x + __y * __y; 685 } 686 }; 687 688 template<typename _Tp> 689 inline _GLIBCXX20_CONSTEXPR _Tp 690 norm(const complex<_Tp>& __z) 691 { 692 return _Norm_helper<__is_floating<_Tp>::__value 693 && !_GLIBCXX_FAST_MATH>::_S_do_it(__z); 694 } 695 696 template<typename _Tp> 697 inline complex<_Tp> 698 polar(const _Tp& __rho, const _Tp& __theta) 699 { 700 __glibcxx_assert( __rho >= 0 ); 701 return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); 702 } 703 704 template<typename _Tp> 705 inline _GLIBCXX20_CONSTEXPR complex<_Tp> 706 conj(const complex<_Tp>& __z) 707 { return complex<_Tp>(__z.real(), -__z.imag()); } 708 709 // Transcendentals 710 711 // 26.2.8/1 cos(__z): Returns the cosine of __z. 712 template<typename _Tp> 713 inline complex<_Tp> 714 __complex_cos(const complex<_Tp>& __z) 715 { 716 const _Tp __x = __z.real(); 717 const _Tp __y = __z.imag(); 718 return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y)); 719 } 720 721#if _GLIBCXX_USE_C99_COMPLEX 722 inline __complex__ float 723 __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); } 724 725 inline __complex__ double 726 __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); } 727 728 inline __complex__ long double 729 __complex_cos(const __complex__ long double& __z) 730 { return __builtin_ccosl(__z); } 731 732 template<typename _Tp> 733 inline complex<_Tp> 734 cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); } 735#else 736 template<typename _Tp> 737 inline complex<_Tp> 738 cos(const complex<_Tp>& __z) { return __complex_cos(__z); } 739#endif 740 741 // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z. 742 template<typename _Tp> 743 inline complex<_Tp> 744 __complex_cosh(const complex<_Tp>& __z) 745 { 746 const _Tp __x = __z.real(); 747 const _Tp __y = __z.imag(); 748 return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y)); 749 } 750 751#if _GLIBCXX_USE_C99_COMPLEX 752 inline __complex__ float 753 __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); } 754 755 inline __complex__ double 756 __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); } 757 758 inline __complex__ long double 759 __complex_cosh(const __complex__ long double& __z) 760 { return __builtin_ccoshl(__z); } 761 762 template<typename _Tp> 763 inline complex<_Tp> 764 cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); } 765#else 766 template<typename _Tp> 767 inline complex<_Tp> 768 cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); } 769#endif 770 771 // 26.2.8/3 exp(__z): Returns the complex base e exponential of x 772 template<typename _Tp> 773 inline complex<_Tp> 774 __complex_exp(const complex<_Tp>& __z) 775 { return std::polar<_Tp>(exp(__z.real()), __z.imag()); } 776 777#if _GLIBCXX_USE_C99_COMPLEX 778 inline __complex__ float 779 __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); } 780 781 inline __complex__ double 782 __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); } 783 784 inline __complex__ long double 785 __complex_exp(const __complex__ long double& __z) 786 { return __builtin_cexpl(__z); } 787 788 template<typename _Tp> 789 inline complex<_Tp> 790 exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); } 791#else 792 template<typename _Tp> 793 inline complex<_Tp> 794 exp(const complex<_Tp>& __z) { return __complex_exp(__z); } 795#endif 796 797 // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z. 798 // The branch cut is along the negative axis. 799 template<typename _Tp> 800 inline complex<_Tp> 801 __complex_log(const complex<_Tp>& __z) 802 { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); } 803 804#if _GLIBCXX_USE_C99_COMPLEX 805 inline __complex__ float 806 __complex_log(__complex__ float __z) { return __builtin_clogf(__z); } 807 808 inline __complex__ double 809 __complex_log(__complex__ double __z) { return __builtin_clog(__z); } 810 811 inline __complex__ long double 812 __complex_log(const __complex__ long double& __z) 813 { return __builtin_clogl(__z); } 814 815 template<typename _Tp> 816 inline complex<_Tp> 817 log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); } 818#else 819 template<typename _Tp> 820 inline complex<_Tp> 821 log(const complex<_Tp>& __z) { return __complex_log(__z); } 822#endif 823 824 template<typename _Tp> 825 inline complex<_Tp> 826 log10(const complex<_Tp>& __z) 827 { return std::log(__z) / log(_Tp(10.0)); } 828 829 // 26.2.8/10 sin(__z): Returns the sine of __z. 830 template<typename _Tp> 831 inline complex<_Tp> 832 __complex_sin(const complex<_Tp>& __z) 833 { 834 const _Tp __x = __z.real(); 835 const _Tp __y = __z.imag(); 836 return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y)); 837 } 838 839#if _GLIBCXX_USE_C99_COMPLEX 840 inline __complex__ float 841 __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); } 842 843 inline __complex__ double 844 __complex_sin(__complex__ double __z) { return __builtin_csin(__z); } 845 846 inline __complex__ long double 847 __complex_sin(const __complex__ long double& __z) 848 { return __builtin_csinl(__z); } 849 850 template<typename _Tp> 851 inline complex<_Tp> 852 sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); } 853#else 854 template<typename _Tp> 855 inline complex<_Tp> 856 sin(const complex<_Tp>& __z) { return __complex_sin(__z); } 857#endif 858 859 // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z. 860 template<typename _Tp> 861 inline complex<_Tp> 862 __complex_sinh(const complex<_Tp>& __z) 863 { 864 const _Tp __x = __z.real(); 865 const _Tp __y = __z.imag(); 866 return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y)); 867 } 868 869#if _GLIBCXX_USE_C99_COMPLEX 870 inline __complex__ float 871 __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); } 872 873 inline __complex__ double 874 __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); } 875 876 inline __complex__ long double 877 __complex_sinh(const __complex__ long double& __z) 878 { return __builtin_csinhl(__z); } 879 880 template<typename _Tp> 881 inline complex<_Tp> 882 sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); } 883#else 884 template<typename _Tp> 885 inline complex<_Tp> 886 sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); } 887#endif 888 889 // 26.2.8/13 sqrt(__z): Returns the complex square root of __z. 890 // The branch cut is on the negative axis. 891 template<typename _Tp> 892 complex<_Tp> 893 __complex_sqrt(const complex<_Tp>& __z) 894 { 895 _Tp __x = __z.real(); 896 _Tp __y = __z.imag(); 897 898 if (__x == _Tp()) 899 { 900 _Tp __t = sqrt(abs(__y) / 2); 901 return complex<_Tp>(__t, __y < _Tp() ? -__t : __t); 902 } 903 else 904 { 905 _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x))); 906 _Tp __u = __t / 2; 907 return __x > _Tp() 908 ? complex<_Tp>(__u, __y / __t) 909 : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u); 910 } 911 } 912 913#if _GLIBCXX_USE_C99_COMPLEX 914 inline __complex__ float 915 __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); } 916 917 inline __complex__ double 918 __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); } 919 920 inline __complex__ long double 921 __complex_sqrt(const __complex__ long double& __z) 922 { return __builtin_csqrtl(__z); } 923 924 template<typename _Tp> 925 inline complex<_Tp> 926 sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); } 927#else 928 template<typename _Tp> 929 inline complex<_Tp> 930 sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); } 931#endif 932 933 // 26.2.8/14 tan(__z): Return the complex tangent of __z. 934 935 template<typename _Tp> 936 inline complex<_Tp> 937 __complex_tan(const complex<_Tp>& __z) 938 { return std::sin(__z) / std::cos(__z); } 939 940#if _GLIBCXX_USE_C99_COMPLEX 941 inline __complex__ float 942 __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); } 943 944 inline __complex__ double 945 __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); } 946 947 inline __complex__ long double 948 __complex_tan(const __complex__ long double& __z) 949 { return __builtin_ctanl(__z); } 950 951 template<typename _Tp> 952 inline complex<_Tp> 953 tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); } 954#else 955 template<typename _Tp> 956 inline complex<_Tp> 957 tan(const complex<_Tp>& __z) { return __complex_tan(__z); } 958#endif 959 960 961 // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z. 962 963 template<typename _Tp> 964 inline complex<_Tp> 965 __complex_tanh(const complex<_Tp>& __z) 966 { return std::sinh(__z) / std::cosh(__z); } 967 968#if _GLIBCXX_USE_C99_COMPLEX 969 inline __complex__ float 970 __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); } 971 972 inline __complex__ double 973 __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); } 974 975 inline __complex__ long double 976 __complex_tanh(const __complex__ long double& __z) 977 { return __builtin_ctanhl(__z); } 978 979 template<typename _Tp> 980 inline complex<_Tp> 981 tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); } 982#else 983 template<typename _Tp> 984 inline complex<_Tp> 985 tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); } 986#endif 987 988 989 // 26.2.8/9 pow(__x, __y): Returns the complex power base of __x 990 // raised to the __y-th power. The branch 991 // cut is on the negative axis. 992 template<typename _Tp> 993 complex<_Tp> 994 __complex_pow_unsigned(complex<_Tp> __x, unsigned __n) 995 { 996 complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1); 997 998 while (__n >>= 1) 999 { 1000 __x *= __x; 1001 if (__n % 2) 1002 __y *= __x; 1003 } 1004 1005 return __y; 1006 } 1007 1008 // In C++11 mode we used to implement the resolution of 1009 // DR 844. complex pow return type is ambiguous. 1010 // thus the following overload was disabled in that mode. However, doing 1011 // that causes all sorts of issues, see, for example: 1012 // http://gcc.gnu.org/ml/libstdc++/2013-01/msg00058.html 1013 // and also PR57974. 1014 template<typename _Tp> 1015 inline complex<_Tp> 1016 pow(const complex<_Tp>& __z, int __n) 1017 { 1018 return __n < 0 1019 ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(unsigned)__n) 1020 : std::__complex_pow_unsigned(__z, __n); 1021 } 1022 1023 template<typename _Tp> 1024 complex<_Tp> 1025 pow(const complex<_Tp>& __x, const _Tp& __y) 1026 { 1027#if ! _GLIBCXX_USE_C99_COMPLEX 1028 if (__x == _Tp()) 1029 return _Tp(); 1030#endif 1031 if (__x.imag() == _Tp() && __x.real() > _Tp()) 1032 return pow(__x.real(), __y); 1033 1034 complex<_Tp> __t = std::log(__x); 1035 return std::polar<_Tp>(exp(__y * __t.real()), __y * __t.imag()); 1036 } 1037 1038 template<typename _Tp> 1039 inline complex<_Tp> 1040 __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y) 1041 { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); } 1042 1043#if _GLIBCXX_USE_C99_COMPLEX 1044 inline __complex__ float 1045 __complex_pow(__complex__ float __x, __complex__ float __y) 1046 { return __builtin_cpowf(__x, __y); } 1047 1048 inline __complex__ double 1049 __complex_pow(__complex__ double __x, __complex__ double __y) 1050 { return __builtin_cpow(__x, __y); } 1051 1052 inline __complex__ long double 1053 __complex_pow(const __complex__ long double& __x, 1054 const __complex__ long double& __y) 1055 { return __builtin_cpowl(__x, __y); } 1056 1057 template<typename _Tp> 1058 inline complex<_Tp> 1059 pow(const complex<_Tp>& __x, const complex<_Tp>& __y) 1060 { return __complex_pow(__x.__rep(), __y.__rep()); } 1061#else 1062 template<typename _Tp> 1063 inline complex<_Tp> 1064 pow(const complex<_Tp>& __x, const complex<_Tp>& __y) 1065 { return __complex_pow(__x, __y); } 1066#endif 1067 1068 template<typename _Tp> 1069 inline complex<_Tp> 1070 pow(const _Tp& __x, const complex<_Tp>& __y) 1071 { 1072 return __x > _Tp() ? std::polar<_Tp>(pow(__x, __y.real()), 1073 __y.imag() * log(__x)) 1074 : std::pow(complex<_Tp>(__x), __y); 1075 } 1076 1077 /// 26.2.3 complex specializations 1078 /// complex<float> specialization 1079 template<> 1080 struct complex<float> 1081 { 1082 typedef float value_type; 1083 typedef __complex__ float _ComplexT; 1084 1085 _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } 1086 1087 _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f) 1088#if __cplusplus >= 201103L 1089 : _M_value{ __r, __i } { } 1090#else 1091 { 1092 __real__ _M_value = __r; 1093 __imag__ _M_value = __i; 1094 } 1095#endif 1096 1097 explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&); 1098 explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&); 1099 1100#if __cplusplus >= 201103L 1101 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1102 // DR 387. std::complex over-encapsulated. 1103 __attribute ((__abi_tag__ ("cxx11"))) 1104 constexpr float 1105 real() const { return __real__ _M_value; } 1106 1107 __attribute ((__abi_tag__ ("cxx11"))) 1108 constexpr float 1109 imag() const { return __imag__ _M_value; } 1110#else 1111 float& 1112 real() { return __real__ _M_value; } 1113 1114 const float& 1115 real() const { return __real__ _M_value; } 1116 1117 float& 1118 imag() { return __imag__ _M_value; } 1119 1120 const float& 1121 imag() const { return __imag__ _M_value; } 1122#endif 1123 1124 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1125 // DR 387. std::complex over-encapsulated. 1126 _GLIBCXX20_CONSTEXPR void 1127 real(float __val) { __real__ _M_value = __val; } 1128 1129 _GLIBCXX20_CONSTEXPR void 1130 imag(float __val) { __imag__ _M_value = __val; } 1131 1132 _GLIBCXX20_CONSTEXPR complex& 1133 operator=(float __f) 1134 { 1135 _M_value = __f; 1136 return *this; 1137 } 1138 1139 _GLIBCXX20_CONSTEXPR complex& 1140 operator+=(float __f) 1141 { 1142 _M_value += __f; 1143 return *this; 1144 } 1145 1146 _GLIBCXX20_CONSTEXPR complex& 1147 operator-=(float __f) 1148 { 1149 _M_value -= __f; 1150 return *this; 1151 } 1152 1153 _GLIBCXX20_CONSTEXPR complex& 1154 operator*=(float __f) 1155 { 1156 _M_value *= __f; 1157 return *this; 1158 } 1159 1160 _GLIBCXX20_CONSTEXPR complex& 1161 operator/=(float __f) 1162 { 1163 _M_value /= __f; 1164 return *this; 1165 } 1166 1167 // Let the compiler synthesize the copy and assignment 1168 // operator. It always does a pretty good job. 1169#if __cplusplus >= 201103L 1170 _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default; 1171#endif 1172 1173 template<typename _Tp> 1174 _GLIBCXX20_CONSTEXPR complex& 1175 operator=(const complex<_Tp>& __z) 1176 { 1177 __real__ _M_value = __z.real(); 1178 __imag__ _M_value = __z.imag(); 1179 return *this; 1180 } 1181 1182 template<typename _Tp> 1183 _GLIBCXX20_CONSTEXPR complex& 1184 operator+=(const complex<_Tp>& __z) 1185 { 1186 _M_value += __z.__rep(); 1187 return *this; 1188 } 1189 1190 template<class _Tp> 1191 _GLIBCXX20_CONSTEXPR complex& 1192 operator-=(const complex<_Tp>& __z) 1193 { 1194 _M_value -= __z.__rep(); 1195 return *this; 1196 } 1197 1198 template<class _Tp> 1199 _GLIBCXX20_CONSTEXPR complex& 1200 operator*=(const complex<_Tp>& __z) 1201 { 1202 const _ComplexT __t = __z.__rep(); 1203 _M_value *= __t; 1204 return *this; 1205 } 1206 1207 template<class _Tp> 1208 _GLIBCXX20_CONSTEXPR complex& 1209 operator/=(const complex<_Tp>& __z) 1210 { 1211 const _ComplexT __t = __z.__rep(); 1212 _M_value /= __t; 1213 return *this; 1214 } 1215 1216 _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; } 1217 1218 private: 1219 _ComplexT _M_value; 1220 }; 1221 1222 /// 26.2.3 complex specializations 1223 /// complex<double> specialization 1224 template<> 1225 struct complex<double> 1226 { 1227 typedef double value_type; 1228 typedef __complex__ double _ComplexT; 1229 1230 _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } 1231 1232 _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0) 1233#if __cplusplus >= 201103L 1234 : _M_value{ __r, __i } { } 1235#else 1236 { 1237 __real__ _M_value = __r; 1238 __imag__ _M_value = __i; 1239 } 1240#endif 1241 1242 _GLIBCXX_CONSTEXPR complex(const complex<float>& __z) 1243 : _M_value(__z.__rep()) { } 1244 1245 explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&); 1246 1247#if __cplusplus >= 201103L 1248 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1249 // DR 387. std::complex over-encapsulated. 1250 __attribute ((__abi_tag__ ("cxx11"))) 1251 constexpr double 1252 real() const { return __real__ _M_value; } 1253 1254 __attribute ((__abi_tag__ ("cxx11"))) 1255 constexpr double 1256 imag() const { return __imag__ _M_value; } 1257#else 1258 double& 1259 real() { return __real__ _M_value; } 1260 1261 const double& 1262 real() const { return __real__ _M_value; } 1263 1264 double& 1265 imag() { return __imag__ _M_value; } 1266 1267 const double& 1268 imag() const { return __imag__ _M_value; } 1269#endif 1270 1271 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1272 // DR 387. std::complex over-encapsulated. 1273 _GLIBCXX20_CONSTEXPR void 1274 real(double __val) { __real__ _M_value = __val; } 1275 1276 _GLIBCXX20_CONSTEXPR void 1277 imag(double __val) { __imag__ _M_value = __val; } 1278 1279 _GLIBCXX20_CONSTEXPR complex& 1280 operator=(double __d) 1281 { 1282 _M_value = __d; 1283 return *this; 1284 } 1285 1286 _GLIBCXX20_CONSTEXPR complex& 1287 operator+=(double __d) 1288 { 1289 _M_value += __d; 1290 return *this; 1291 } 1292 1293 _GLIBCXX20_CONSTEXPR complex& 1294 operator-=(double __d) 1295 { 1296 _M_value -= __d; 1297 return *this; 1298 } 1299 1300 _GLIBCXX20_CONSTEXPR complex& 1301 operator*=(double __d) 1302 { 1303 _M_value *= __d; 1304 return *this; 1305 } 1306 1307 _GLIBCXX20_CONSTEXPR complex& 1308 operator/=(double __d) 1309 { 1310 _M_value /= __d; 1311 return *this; 1312 } 1313 1314 // The compiler will synthesize this, efficiently. 1315#if __cplusplus >= 201103L 1316 _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default; 1317#endif 1318 1319 template<typename _Tp> 1320 _GLIBCXX20_CONSTEXPR complex& 1321 operator=(const complex<_Tp>& __z) 1322 { 1323 _M_value = __z.__rep(); 1324 return *this; 1325 } 1326 1327 template<typename _Tp> 1328 _GLIBCXX20_CONSTEXPR complex& 1329 operator+=(const complex<_Tp>& __z) 1330 { 1331 _M_value += __z.__rep(); 1332 return *this; 1333 } 1334 1335 template<typename _Tp> 1336 _GLIBCXX20_CONSTEXPR complex& 1337 operator-=(const complex<_Tp>& __z) 1338 { 1339 _M_value -= __z.__rep(); 1340 return *this; 1341 } 1342 1343 template<typename _Tp> 1344 _GLIBCXX20_CONSTEXPR complex& 1345 operator*=(const complex<_Tp>& __z) 1346 { 1347 const _ComplexT __t = __z.__rep(); 1348 _M_value *= __t; 1349 return *this; 1350 } 1351 1352 template<typename _Tp> 1353 _GLIBCXX20_CONSTEXPR complex& 1354 operator/=(const complex<_Tp>& __z) 1355 { 1356 const _ComplexT __t = __z.__rep(); 1357 _M_value /= __t; 1358 return *this; 1359 } 1360 1361 _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; } 1362 1363 private: 1364 _ComplexT _M_value; 1365 }; 1366 1367 /// 26.2.3 complex specializations 1368 /// complex<long double> specialization 1369 template<> 1370 struct complex<long double> 1371 { 1372 typedef long double value_type; 1373 typedef __complex__ long double _ComplexT; 1374 1375 _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } 1376 1377 _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L, 1378 long double __i = 0.0L) 1379#if __cplusplus >= 201103L 1380 : _M_value{ __r, __i } { } 1381#else 1382 { 1383 __real__ _M_value = __r; 1384 __imag__ _M_value = __i; 1385 } 1386#endif 1387 1388 _GLIBCXX_CONSTEXPR complex(const complex<float>& __z) 1389 : _M_value(__z.__rep()) { } 1390 1391 _GLIBCXX_CONSTEXPR complex(const complex<double>& __z) 1392 : _M_value(__z.__rep()) { } 1393 1394#if __cplusplus >= 201103L 1395 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1396 // DR 387. std::complex over-encapsulated. 1397 __attribute ((__abi_tag__ ("cxx11"))) 1398 constexpr long double 1399 real() const { return __real__ _M_value; } 1400 1401 __attribute ((__abi_tag__ ("cxx11"))) 1402 constexpr long double 1403 imag() const { return __imag__ _M_value; } 1404#else 1405 long double& 1406 real() { return __real__ _M_value; } 1407 1408 const long double& 1409 real() const { return __real__ _M_value; } 1410 1411 long double& 1412 imag() { return __imag__ _M_value; } 1413 1414 const long double& 1415 imag() const { return __imag__ _M_value; } 1416#endif 1417 1418 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1419 // DR 387. std::complex over-encapsulated. 1420 _GLIBCXX20_CONSTEXPR void 1421 real(long double __val) { __real__ _M_value = __val; } 1422 1423 _GLIBCXX20_CONSTEXPR void 1424 imag(long double __val) { __imag__ _M_value = __val; } 1425 1426 _GLIBCXX20_CONSTEXPR complex& 1427 operator=(long double __r) 1428 { 1429 _M_value = __r; 1430 return *this; 1431 } 1432 1433 _GLIBCXX20_CONSTEXPR complex& 1434 operator+=(long double __r) 1435 { 1436 _M_value += __r; 1437 return *this; 1438 } 1439 1440 _GLIBCXX20_CONSTEXPR complex& 1441 operator-=(long double __r) 1442 { 1443 _M_value -= __r; 1444 return *this; 1445 } 1446 1447 _GLIBCXX20_CONSTEXPR complex& 1448 operator*=(long double __r) 1449 { 1450 _M_value *= __r; 1451 return *this; 1452 } 1453 1454 _GLIBCXX20_CONSTEXPR complex& 1455 operator/=(long double __r) 1456 { 1457 _M_value /= __r; 1458 return *this; 1459 } 1460 1461 // The compiler knows how to do this efficiently 1462#if __cplusplus >= 201103L 1463 _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default; 1464#endif 1465 1466 template<typename _Tp> 1467 _GLIBCXX20_CONSTEXPR complex& 1468 operator=(const complex<_Tp>& __z) 1469 { 1470 _M_value = __z.__rep(); 1471 return *this; 1472 } 1473 1474 template<typename _Tp> 1475 _GLIBCXX20_CONSTEXPR complex& 1476 operator+=(const complex<_Tp>& __z) 1477 { 1478 _M_value += __z.__rep(); 1479 return *this; 1480 } 1481 1482 template<typename _Tp> 1483 _GLIBCXX20_CONSTEXPR complex& 1484 operator-=(const complex<_Tp>& __z) 1485 { 1486 _M_value -= __z.__rep(); 1487 return *this; 1488 } 1489 1490 template<typename _Tp> 1491 _GLIBCXX20_CONSTEXPR complex& 1492 operator*=(const complex<_Tp>& __z) 1493 { 1494 const _ComplexT __t = __z.__rep(); 1495 _M_value *= __t; 1496 return *this; 1497 } 1498 1499 template<typename _Tp> 1500 _GLIBCXX20_CONSTEXPR complex& 1501 operator/=(const complex<_Tp>& __z) 1502 { 1503 const _ComplexT __t = __z.__rep(); 1504 _M_value /= __t; 1505 return *this; 1506 } 1507 1508 _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; } 1509 1510 private: 1511 _ComplexT _M_value; 1512 }; 1513 1514 // These bits have to be at the end of this file, so that the 1515 // specializations have all been defined. 1516 inline _GLIBCXX_CONSTEXPR 1517 complex<float>::complex(const complex<double>& __z) 1518 : _M_value(__z.__rep()) { } 1519 1520 inline _GLIBCXX_CONSTEXPR 1521 complex<float>::complex(const complex<long double>& __z) 1522 : _M_value(__z.__rep()) { } 1523 1524 inline _GLIBCXX_CONSTEXPR 1525 complex<double>::complex(const complex<long double>& __z) 1526 : _M_value(__z.__rep()) { } 1527 1528 // Inhibit implicit instantiations for required instantiations, 1529 // which are defined via explicit instantiations elsewhere. 1530 // NB: This syntax is a GNU extension. 1531#if _GLIBCXX_EXTERN_TEMPLATE 1532 extern template istream& operator>>(istream&, complex<float>&); 1533 extern template ostream& operator<<(ostream&, const complex<float>&); 1534 extern template istream& operator>>(istream&, complex<double>&); 1535 extern template ostream& operator<<(ostream&, const complex<double>&); 1536 extern template istream& operator>>(istream&, complex<long double>&); 1537 extern template ostream& operator<<(ostream&, const complex<long double>&); 1538 1539#ifdef _GLIBCXX_USE_WCHAR_T 1540 extern template wistream& operator>>(wistream&, complex<float>&); 1541 extern template wostream& operator<<(wostream&, const complex<float>&); 1542 extern template wistream& operator>>(wistream&, complex<double>&); 1543 extern template wostream& operator<<(wostream&, const complex<double>&); 1544 extern template wistream& operator>>(wistream&, complex<long double>&); 1545 extern template wostream& operator<<(wostream&, const complex<long double>&); 1546#endif 1547#endif 1548 1549 /// @} group complex_numbers 1550 1551_GLIBCXX_END_NAMESPACE_VERSION 1552} // namespace 1553 1554namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) 1555{ 1556_GLIBCXX_BEGIN_NAMESPACE_VERSION 1557 1558 // See ext/type_traits.h for the primary template. 1559 template<typename _Tp, typename _Up> 1560 struct __promote_2<std::complex<_Tp>, _Up> 1561 { 1562 public: 1563 typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type; 1564 }; 1565 1566 template<typename _Tp, typename _Up> 1567 struct __promote_2<_Tp, std::complex<_Up> > 1568 { 1569 public: 1570 typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type; 1571 }; 1572 1573 template<typename _Tp, typename _Up> 1574 struct __promote_2<std::complex<_Tp>, std::complex<_Up> > 1575 { 1576 public: 1577 typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type; 1578 }; 1579 1580_GLIBCXX_END_NAMESPACE_VERSION 1581} // namespace 1582 1583#if __cplusplus >= 201103L 1584 1585namespace std _GLIBCXX_VISIBILITY(default) 1586{ 1587_GLIBCXX_BEGIN_NAMESPACE_VERSION 1588 1589 // Forward declarations. 1590 template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&); 1591 template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&); 1592 template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&); 1593 1594 template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&); 1595 template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&); 1596 template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&); 1597 // DR 595. 1598 template<typename _Tp> _Tp fabs(const std::complex<_Tp>&); 1599 1600 template<typename _Tp> 1601 inline std::complex<_Tp> 1602 __complex_acos(const std::complex<_Tp>& __z) 1603 { 1604 const std::complex<_Tp> __t = std::asin(__z); 1605 const _Tp __pi_2 = 1.5707963267948966192313216916397514L; 1606 return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag()); 1607 } 1608 1609#if _GLIBCXX_USE_C99_COMPLEX_TR1 1610 inline __complex__ float 1611 __complex_acos(__complex__ float __z) 1612 { return __builtin_cacosf(__z); } 1613 1614 inline __complex__ double 1615 __complex_acos(__complex__ double __z) 1616 { return __builtin_cacos(__z); } 1617 1618 inline __complex__ long double 1619 __complex_acos(const __complex__ long double& __z) 1620 { return __builtin_cacosl(__z); } 1621 1622 template<typename _Tp> 1623 inline std::complex<_Tp> 1624 acos(const std::complex<_Tp>& __z) 1625 { return __complex_acos(__z.__rep()); } 1626#else 1627 /// acos(__z) [8.1.2]. 1628 // Effects: Behaves the same as C99 function cacos, defined 1629 // in subclause 7.3.5.1. 1630 template<typename _Tp> 1631 inline std::complex<_Tp> 1632 acos(const std::complex<_Tp>& __z) 1633 { return __complex_acos(__z); } 1634#endif 1635 1636 template<typename _Tp> 1637 inline std::complex<_Tp> 1638 __complex_asin(const std::complex<_Tp>& __z) 1639 { 1640 std::complex<_Tp> __t(-__z.imag(), __z.real()); 1641 __t = std::asinh(__t); 1642 return std::complex<_Tp>(__t.imag(), -__t.real()); 1643 } 1644 1645#if _GLIBCXX_USE_C99_COMPLEX_TR1 1646 inline __complex__ float 1647 __complex_asin(__complex__ float __z) 1648 { return __builtin_casinf(__z); } 1649 1650 inline __complex__ double 1651 __complex_asin(__complex__ double __z) 1652 { return __builtin_casin(__z); } 1653 1654 inline __complex__ long double 1655 __complex_asin(const __complex__ long double& __z) 1656 { return __builtin_casinl(__z); } 1657 1658 template<typename _Tp> 1659 inline std::complex<_Tp> 1660 asin(const std::complex<_Tp>& __z) 1661 { return __complex_asin(__z.__rep()); } 1662#else 1663 /// asin(__z) [8.1.3]. 1664 // Effects: Behaves the same as C99 function casin, defined 1665 // in subclause 7.3.5.2. 1666 template<typename _Tp> 1667 inline std::complex<_Tp> 1668 asin(const std::complex<_Tp>& __z) 1669 { return __complex_asin(__z); } 1670#endif 1671 1672 template<typename _Tp> 1673 std::complex<_Tp> 1674 __complex_atan(const std::complex<_Tp>& __z) 1675 { 1676 const _Tp __r2 = __z.real() * __z.real(); 1677 const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag(); 1678 1679 _Tp __num = __z.imag() + _Tp(1.0); 1680 _Tp __den = __z.imag() - _Tp(1.0); 1681 1682 __num = __r2 + __num * __num; 1683 __den = __r2 + __den * __den; 1684 1685 return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x), 1686 _Tp(0.25) * log(__num / __den)); 1687 } 1688 1689#if _GLIBCXX_USE_C99_COMPLEX_TR1 1690 inline __complex__ float 1691 __complex_atan(__complex__ float __z) 1692 { return __builtin_catanf(__z); } 1693 1694 inline __complex__ double 1695 __complex_atan(__complex__ double __z) 1696 { return __builtin_catan(__z); } 1697 1698 inline __complex__ long double 1699 __complex_atan(const __complex__ long double& __z) 1700 { return __builtin_catanl(__z); } 1701 1702 template<typename _Tp> 1703 inline std::complex<_Tp> 1704 atan(const std::complex<_Tp>& __z) 1705 { return __complex_atan(__z.__rep()); } 1706#else 1707 /// atan(__z) [8.1.4]. 1708 // Effects: Behaves the same as C99 function catan, defined 1709 // in subclause 7.3.5.3. 1710 template<typename _Tp> 1711 inline std::complex<_Tp> 1712 atan(const std::complex<_Tp>& __z) 1713 { return __complex_atan(__z); } 1714#endif 1715 1716 template<typename _Tp> 1717 std::complex<_Tp> 1718 __complex_acosh(const std::complex<_Tp>& __z) 1719 { 1720 // Kahan's formula. 1721 return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0))) 1722 + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0)))); 1723 } 1724 1725#if _GLIBCXX_USE_C99_COMPLEX_TR1 1726 inline __complex__ float 1727 __complex_acosh(__complex__ float __z) 1728 { return __builtin_cacoshf(__z); } 1729 1730 inline __complex__ double 1731 __complex_acosh(__complex__ double __z) 1732 { return __builtin_cacosh(__z); } 1733 1734 inline __complex__ long double 1735 __complex_acosh(const __complex__ long double& __z) 1736 { return __builtin_cacoshl(__z); } 1737 1738 template<typename _Tp> 1739 inline std::complex<_Tp> 1740 acosh(const std::complex<_Tp>& __z) 1741 { return __complex_acosh(__z.__rep()); } 1742#else 1743 /// acosh(__z) [8.1.5]. 1744 // Effects: Behaves the same as C99 function cacosh, defined 1745 // in subclause 7.3.6.1. 1746 template<typename _Tp> 1747 inline std::complex<_Tp> 1748 acosh(const std::complex<_Tp>& __z) 1749 { return __complex_acosh(__z); } 1750#endif 1751 1752 template<typename _Tp> 1753 std::complex<_Tp> 1754 __complex_asinh(const std::complex<_Tp>& __z) 1755 { 1756 std::complex<_Tp> __t((__z.real() - __z.imag()) 1757 * (__z.real() + __z.imag()) + _Tp(1.0), 1758 _Tp(2.0) * __z.real() * __z.imag()); 1759 __t = std::sqrt(__t); 1760 1761 return std::log(__t + __z); 1762 } 1763 1764#if _GLIBCXX_USE_C99_COMPLEX_TR1 1765 inline __complex__ float 1766 __complex_asinh(__complex__ float __z) 1767 { return __builtin_casinhf(__z); } 1768 1769 inline __complex__ double 1770 __complex_asinh(__complex__ double __z) 1771 { return __builtin_casinh(__z); } 1772 1773 inline __complex__ long double 1774 __complex_asinh(const __complex__ long double& __z) 1775 { return __builtin_casinhl(__z); } 1776 1777 template<typename _Tp> 1778 inline std::complex<_Tp> 1779 asinh(const std::complex<_Tp>& __z) 1780 { return __complex_asinh(__z.__rep()); } 1781#else 1782 /// asinh(__z) [8.1.6]. 1783 // Effects: Behaves the same as C99 function casin, defined 1784 // in subclause 7.3.6.2. 1785 template<typename _Tp> 1786 inline std::complex<_Tp> 1787 asinh(const std::complex<_Tp>& __z) 1788 { return __complex_asinh(__z); } 1789#endif 1790 1791 template<typename _Tp> 1792 std::complex<_Tp> 1793 __complex_atanh(const std::complex<_Tp>& __z) 1794 { 1795 const _Tp __i2 = __z.imag() * __z.imag(); 1796 const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real(); 1797 1798 _Tp __num = _Tp(1.0) + __z.real(); 1799 _Tp __den = _Tp(1.0) - __z.real(); 1800 1801 __num = __i2 + __num * __num; 1802 __den = __i2 + __den * __den; 1803 1804 return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)), 1805 _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x)); 1806 } 1807 1808#if _GLIBCXX_USE_C99_COMPLEX_TR1 1809 inline __complex__ float 1810 __complex_atanh(__complex__ float __z) 1811 { return __builtin_catanhf(__z); } 1812 1813 inline __complex__ double 1814 __complex_atanh(__complex__ double __z) 1815 { return __builtin_catanh(__z); } 1816 1817 inline __complex__ long double 1818 __complex_atanh(const __complex__ long double& __z) 1819 { return __builtin_catanhl(__z); } 1820 1821 template<typename _Tp> 1822 inline std::complex<_Tp> 1823 atanh(const std::complex<_Tp>& __z) 1824 { return __complex_atanh(__z.__rep()); } 1825#else 1826 /// atanh(__z) [8.1.7]. 1827 // Effects: Behaves the same as C99 function catanh, defined 1828 // in subclause 7.3.6.3. 1829 template<typename _Tp> 1830 inline std::complex<_Tp> 1831 atanh(const std::complex<_Tp>& __z) 1832 { return __complex_atanh(__z); } 1833#endif 1834 1835 template<typename _Tp> 1836 inline _Tp 1837 /// fabs(__z) [8.1.8]. 1838 // Effects: Behaves the same as C99 function cabs, defined 1839 // in subclause 7.3.8.1. 1840 fabs(const std::complex<_Tp>& __z) 1841 { return std::abs(__z); } 1842 1843 /// Additional overloads [8.1.9]. 1844 template<typename _Tp> 1845 inline typename __gnu_cxx::__promote<_Tp>::__type 1846 arg(_Tp __x) 1847 { 1848 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1849#if (_GLIBCXX11_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC) 1850 return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L) 1851 : __type(); 1852#else 1853 return std::arg(std::complex<__type>(__x)); 1854#endif 1855 } 1856 1857 template<typename _Tp> 1858 _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type 1859 imag(_Tp) 1860 { return _Tp(); } 1861 1862 template<typename _Tp> 1863 _GLIBCXX20_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type 1864 norm(_Tp __x) 1865 { 1866 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1867 return __type(__x) * __type(__x); 1868 } 1869 1870 template<typename _Tp> 1871 _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type 1872 real(_Tp __x) 1873 { return __x; } 1874 1875 template<typename _Tp, typename _Up> 1876 inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type> 1877 pow(const std::complex<_Tp>& __x, const _Up& __y) 1878 { 1879 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1880 return std::pow(std::complex<__type>(__x), __type(__y)); 1881 } 1882 1883 template<typename _Tp, typename _Up> 1884 inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type> 1885 pow(const _Tp& __x, const std::complex<_Up>& __y) 1886 { 1887 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1888 return std::pow(__type(__x), std::complex<__type>(__y)); 1889 } 1890 1891 template<typename _Tp, typename _Up> 1892 inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type> 1893 pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y) 1894 { 1895 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1896 return std::pow(std::complex<__type>(__x), 1897 std::complex<__type>(__y)); 1898 } 1899 1900 // Forward declarations. 1901 // DR 781. 1902 template<typename _Tp> 1903 std::complex<_Tp> proj(const std::complex<_Tp>&); 1904 1905 // Generic implementation of std::proj, does not work for infinities. 1906 template<typename _Tp> 1907 inline std::complex<_Tp> 1908 __complex_proj(const std::complex<_Tp>& __z) 1909 { return __z; } 1910 1911#if _GLIBCXX_USE_C99_COMPLEX 1912 inline complex<float> 1913 __complex_proj(const complex<float>& __z) 1914 { return __builtin_cprojf(__z.__rep()); } 1915 1916 inline complex<double> 1917 __complex_proj(const complex<double>& __z) 1918 { return __builtin_cproj(__z.__rep()); } 1919 1920 inline complex<long double> 1921 __complex_proj(const complex<long double>& __z) 1922 { return __builtin_cprojl(__z.__rep()); } 1923#elif defined _GLIBCXX_USE_C99_MATH_TR1 1924 inline complex<float> 1925 __complex_proj(const complex<float>& __z) 1926 { 1927 if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag())) 1928 return complex<float>(__builtin_inff(), 1929 __builtin_copysignf(0.0f, __z.imag())); 1930 return __z; 1931 } 1932 1933 inline complex<double> 1934 __complex_proj(const complex<double>& __z) 1935 { 1936 if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag())) 1937 return complex<double>(__builtin_inf(), 1938 __builtin_copysign(0.0, __z.imag())); 1939 return __z; 1940 } 1941 1942 inline complex<long double> 1943 __complex_proj(const complex<long double>& __z) 1944 { 1945 if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag())) 1946 return complex<long double>(__builtin_infl(), 1947 __builtin_copysignl(0.0l, __z.imag())); 1948 return __z; 1949 } 1950#endif 1951 1952 template<typename _Tp> 1953 inline std::complex<_Tp> 1954 proj(const std::complex<_Tp>& __z) 1955 { return __complex_proj(__z); } 1956 1957 // Overload for scalars 1958 template<typename _Tp> 1959 inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type> 1960 proj(_Tp __x) 1961 { 1962 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1963 return std::proj(std::complex<__type>(__x)); 1964 } 1965 1966 template<typename _Tp> 1967 inline _GLIBCXX20_CONSTEXPR 1968 std::complex<typename __gnu_cxx::__promote<_Tp>::__type> 1969 conj(_Tp __x) 1970 { 1971 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1972 return std::complex<__type>(__x, -__type()); 1973 } 1974 1975#if __cplusplus > 201103L 1976 1977inline namespace literals { 1978inline namespace complex_literals { 1979#pragma GCC diagnostic push 1980#pragma GCC diagnostic ignored "-Wliteral-suffix" 1981#define __cpp_lib_complex_udls 201309 1982 1983 constexpr std::complex<float> 1984 operator""if(long double __num) 1985 { return std::complex<float>{0.0F, static_cast<float>(__num)}; } 1986 1987 constexpr std::complex<float> 1988 operator""if(unsigned long long __num) 1989 { return std::complex<float>{0.0F, static_cast<float>(__num)}; } 1990 1991 constexpr std::complex<double> 1992 operator""i(long double __num) 1993 { return std::complex<double>{0.0, static_cast<double>(__num)}; } 1994 1995 constexpr std::complex<double> 1996 operator""i(unsigned long long __num) 1997 { return std::complex<double>{0.0, static_cast<double>(__num)}; } 1998 1999 constexpr std::complex<long double> 2000 operator""il(long double __num) 2001 { return std::complex<long double>{0.0L, __num}; } 2002 2003 constexpr std::complex<long double> 2004 operator""il(unsigned long long __num) 2005 { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; } 2006 2007#pragma GCC diagnostic pop 2008} // inline namespace complex_literals 2009} // inline namespace literals 2010 2011#endif // C++14 2012 2013_GLIBCXX_END_NAMESPACE_VERSION 2014} // namespace 2015 2016#endif // C++11 2017 2018#endif /* _GLIBCXX_COMPLEX */ 2019