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