1// The template and inlines for the -*- C++ -*- complex number classes. 2 3// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 4// 2006, 2007, 2008, 2009, 2010 5// Free Software Foundation, Inc. 6// 7// This file is part of the GNU ISO C++ Library. This library is free 8// software; you can redistribute it and/or modify it under the 9// terms of the GNU General Public License as published by the 10// Free Software Foundation; either version 3, or (at your option) 11// any later version. 12 13// This library is distributed in the hope that it will be useful, 14// but WITHOUT ANY WARRANTY; without even the implied warranty of 15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16// GNU General Public License for more details. 17 18// Under Section 7 of GPL version 3, you are granted additional 19// permissions described in the GCC Runtime Library Exception, version 20// 3.1, as published by the Free Software Foundation. 21 22// You should have received a copy of the GNU General Public License and 23// a copy of the GCC Runtime Library Exception along with this program; 24// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 25// <http://www.gnu.org/licenses/>. 26 27/** @file include/complex 28 * This is a Standard C++ Library header. 29 */ 30 31// 32// ISO C++ 14882: 26.2 Complex Numbers 33// Note: this is not a conforming implementation. 34// Initially implemented by Ulrich Drepper <drepper@cygnus.com> 35// Improved by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> 36// 37 38#ifndef _GLIBCXX_COMPLEX 39#define _GLIBCXX_COMPLEX 1 40 41#pragma GCC system_header 42 43#include <bits/c++config.h> 44#include <bits/cpp_type_traits.h> 45#include <ext/type_traits.h> 46#include <cmath> 47#include <sstream> 48 49_GLIBCXX_BEGIN_NAMESPACE(std) 50 51 /** 52 * @defgroup complex_numbers Complex Numbers 53 * @ingroup numerics 54 * 55 * Classes and functions for complex numbers. 56 * @{ 57 */ 58 59 // Forward declarations. 60 template<typename _Tp> class complex; 61 template<> class complex<float>; 62 template<> class complex<double>; 63 template<> class complex<long double>; 64 65 /// Return magnitude of @a z. 66 template<typename _Tp> _Tp abs(const complex<_Tp>&); 67 /// Return phase angle of @a z. 68 template<typename _Tp> _Tp arg(const complex<_Tp>&); 69 /// Return @a z magnitude squared. 70 template<typename _Tp> _Tp norm(const complex<_Tp>&); 71 72 /// Return complex conjugate of @a z. 73 template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&); 74 /// Return complex with magnitude @a rho and angle @a theta. 75 template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0); 76 77 // Transcendentals: 78 /// Return complex cosine of @a z. 79 template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&); 80 /// Return complex hyperbolic cosine of @a z. 81 template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&); 82 /// Return complex base e exponential of @a z. 83 template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&); 84 /// Return complex natural logarithm of @a z. 85 template<typename _Tp> complex<_Tp> log(const complex<_Tp>&); 86 /// Return complex base 10 logarithm of @a z. 87 template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&); 88#ifndef __GXX_EXPERIMENTAL_CXX0X__ 89 // DR 844. 90 /// Return @a x to the @a y'th power. 91 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int); 92#endif 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 complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp()) 130 : _M_real(__r), _M_imag(__i) { } 131 132 // Lets the compiler synthesize the copy constructor 133 // complex (const complex<_Tp>&); 134 /// Copy constructor. 135 template<typename _Up> 136 complex(const complex<_Up>& __z) 137 : _M_real(__z.real()), _M_imag(__z.imag()) { } 138 139#ifdef __GXX_EXPERIMENTAL_CXX0X__ 140 // _GLIBCXX_RESOLVE_LIB_DEFECTS 141 // DR 387. std::complex over-encapsulated. 142 _Tp real() const 143 { return _M_real; } 144 145 _Tp imag() const 146 { return _M_imag; } 147#else 148 /// Return real part of complex number. 149 _Tp& real() 150 { return _M_real; } 151 152 /// Return real part of complex number. 153 const _Tp& real() const 154 { return _M_real; } 155 156 /// Return imaginary part of complex number. 157 _Tp& imag() 158 { return _M_imag; } 159 160 /// Return imaginary part of complex number. 161 const _Tp& imag() const 162 { return _M_imag; } 163#endif 164 165 // _GLIBCXX_RESOLVE_LIB_DEFECTS 166 // DR 387. std::complex over-encapsulated. 167 void real(_Tp __val) 168 { _M_real = __val; } 169 170 void imag(_Tp __val) 171 { _M_imag = __val; } 172 173 /// Assign this complex number to scalar @a t. 174 complex<_Tp>& operator=(const _Tp&); 175 176 /// Add @a t to this complex number. 177 // 26.2.5/1 178 complex<_Tp>& 179 operator+=(const _Tp& __t) 180 { 181 _M_real += __t; 182 return *this; 183 } 184 185 /// Subtract @a t from this complex number. 186 // 26.2.5/3 187 complex<_Tp>& 188 operator-=(const _Tp& __t) 189 { 190 _M_real -= __t; 191 return *this; 192 } 193 194 /// Multiply this complex number by @a t. 195 complex<_Tp>& operator*=(const _Tp&); 196 /// Divide this complex number by @a t. 197 complex<_Tp>& operator/=(const _Tp&); 198 199 // Lets the compiler synthesize the 200 // copy and assignment operator 201 // complex<_Tp>& operator= (const complex<_Tp>&); 202 /// Assign this complex number to complex @a z. 203 template<typename _Up> 204 complex<_Tp>& operator=(const complex<_Up>&); 205 /// Add @a z to this complex number. 206 template<typename _Up> 207 complex<_Tp>& operator+=(const complex<_Up>&); 208 /// Subtract @a z from this complex number. 209 template<typename _Up> 210 complex<_Tp>& operator-=(const complex<_Up>&); 211 /// Multiply this complex number by @a z. 212 template<typename _Up> 213 complex<_Tp>& operator*=(const complex<_Up>&); 214 /// Divide this complex number by @a z. 215 template<typename _Up> 216 complex<_Tp>& operator/=(const complex<_Up>&); 217 218 const complex& __rep() const 219 { return *this; } 220 221 private: 222 _Tp _M_real; 223 _Tp _M_imag; 224 }; 225 226 template<typename _Tp> 227 complex<_Tp>& 228 complex<_Tp>::operator=(const _Tp& __t) 229 { 230 _M_real = __t; 231 _M_imag = _Tp(); 232 return *this; 233 } 234 235 // 26.2.5/5 236 template<typename _Tp> 237 complex<_Tp>& 238 complex<_Tp>::operator*=(const _Tp& __t) 239 { 240 _M_real *= __t; 241 _M_imag *= __t; 242 return *this; 243 } 244 245 // 26.2.5/7 246 template<typename _Tp> 247 complex<_Tp>& 248 complex<_Tp>::operator/=(const _Tp& __t) 249 { 250 _M_real /= __t; 251 _M_imag /= __t; 252 return *this; 253 } 254 255 template<typename _Tp> 256 template<typename _Up> 257 complex<_Tp>& 258 complex<_Tp>::operator=(const complex<_Up>& __z) 259 { 260 _M_real = __z.real(); 261 _M_imag = __z.imag(); 262 return *this; 263 } 264 265 // 26.2.5/9 266 template<typename _Tp> 267 template<typename _Up> 268 complex<_Tp>& 269 complex<_Tp>::operator+=(const complex<_Up>& __z) 270 { 271 _M_real += __z.real(); 272 _M_imag += __z.imag(); 273 return *this; 274 } 275 276 // 26.2.5/11 277 template<typename _Tp> 278 template<typename _Up> 279 complex<_Tp>& 280 complex<_Tp>::operator-=(const complex<_Up>& __z) 281 { 282 _M_real -= __z.real(); 283 _M_imag -= __z.imag(); 284 return *this; 285 } 286 287 // 26.2.5/13 288 // XXX: This is a grammar school implementation. 289 template<typename _Tp> 290 template<typename _Up> 291 complex<_Tp>& 292 complex<_Tp>::operator*=(const complex<_Up>& __z) 293 { 294 const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag(); 295 _M_imag = _M_real * __z.imag() + _M_imag * __z.real(); 296 _M_real = __r; 297 return *this; 298 } 299 300 // 26.2.5/15 301 // XXX: This is a grammar school implementation. 302 template<typename _Tp> 303 template<typename _Up> 304 complex<_Tp>& 305 complex<_Tp>::operator/=(const complex<_Up>& __z) 306 { 307 const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag(); 308 const _Tp __n = std::norm(__z); 309 _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n; 310 _M_real = __r / __n; 311 return *this; 312 } 313 314 // Operators: 315 //@{ 316 /// Return new complex value @a x plus @a y. 317 template<typename _Tp> 318 inline complex<_Tp> 319 operator+(const complex<_Tp>& __x, const complex<_Tp>& __y) 320 { 321 complex<_Tp> __r = __x; 322 __r += __y; 323 return __r; 324 } 325 326 template<typename _Tp> 327 inline complex<_Tp> 328 operator+(const complex<_Tp>& __x, const _Tp& __y) 329 { 330 complex<_Tp> __r = __x; 331 __r += __y; 332 return __r; 333 } 334 335 template<typename _Tp> 336 inline complex<_Tp> 337 operator+(const _Tp& __x, const complex<_Tp>& __y) 338 { 339 complex<_Tp> __r = __y; 340 __r += __x; 341 return __r; 342 } 343 //@} 344 345 //@{ 346 /// Return new complex value @a x minus @a y. 347 template<typename _Tp> 348 inline complex<_Tp> 349 operator-(const complex<_Tp>& __x, const complex<_Tp>& __y) 350 { 351 complex<_Tp> __r = __x; 352 __r -= __y; 353 return __r; 354 } 355 356 template<typename _Tp> 357 inline complex<_Tp> 358 operator-(const complex<_Tp>& __x, const _Tp& __y) 359 { 360 complex<_Tp> __r = __x; 361 __r -= __y; 362 return __r; 363 } 364 365 template<typename _Tp> 366 inline complex<_Tp> 367 operator-(const _Tp& __x, const complex<_Tp>& __y) 368 { 369 complex<_Tp> __r(__x, -__y.imag()); 370 __r -= __y.real(); 371 return __r; 372 } 373 //@} 374 375 //@{ 376 /// Return new complex value @a x times @a y. 377 template<typename _Tp> 378 inline complex<_Tp> 379 operator*(const complex<_Tp>& __x, const complex<_Tp>& __y) 380 { 381 complex<_Tp> __r = __x; 382 __r *= __y; 383 return __r; 384 } 385 386 template<typename _Tp> 387 inline complex<_Tp> 388 operator*(const complex<_Tp>& __x, const _Tp& __y) 389 { 390 complex<_Tp> __r = __x; 391 __r *= __y; 392 return __r; 393 } 394 395 template<typename _Tp> 396 inline complex<_Tp> 397 operator*(const _Tp& __x, const complex<_Tp>& __y) 398 { 399 complex<_Tp> __r = __y; 400 __r *= __x; 401 return __r; 402 } 403 //@} 404 405 //@{ 406 /// Return new complex value @a x divided by @a y. 407 template<typename _Tp> 408 inline complex<_Tp> 409 operator/(const complex<_Tp>& __x, const complex<_Tp>& __y) 410 { 411 complex<_Tp> __r = __x; 412 __r /= __y; 413 return __r; 414 } 415 416 template<typename _Tp> 417 inline complex<_Tp> 418 operator/(const complex<_Tp>& __x, const _Tp& __y) 419 { 420 complex<_Tp> __r = __x; 421 __r /= __y; 422 return __r; 423 } 424 425 template<typename _Tp> 426 inline complex<_Tp> 427 operator/(const _Tp& __x, const complex<_Tp>& __y) 428 { 429 complex<_Tp> __r = __x; 430 __r /= __y; 431 return __r; 432 } 433 //@} 434 435 /// Return @a x. 436 template<typename _Tp> 437 inline complex<_Tp> 438 operator+(const complex<_Tp>& __x) 439 { return __x; } 440 441 /// Return complex negation of @a x. 442 template<typename _Tp> 443 inline complex<_Tp> 444 operator-(const complex<_Tp>& __x) 445 { return complex<_Tp>(-__x.real(), -__x.imag()); } 446 447 //@{ 448 /// Return true if @a x is equal to @a y. 449 template<typename _Tp> 450 inline bool 451 operator==(const complex<_Tp>& __x, const complex<_Tp>& __y) 452 { return __x.real() == __y.real() && __x.imag() == __y.imag(); } 453 454 template<typename _Tp> 455 inline bool 456 operator==(const complex<_Tp>& __x, const _Tp& __y) 457 { return __x.real() == __y && __x.imag() == _Tp(); } 458 459 template<typename _Tp> 460 inline bool 461 operator==(const _Tp& __x, const complex<_Tp>& __y) 462 { return __x == __y.real() && _Tp() == __y.imag(); } 463 //@} 464 465 //@{ 466 /// Return false if @a x is equal to @a y. 467 template<typename _Tp> 468 inline bool 469 operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y) 470 { return __x.real() != __y.real() || __x.imag() != __y.imag(); } 471 472 template<typename _Tp> 473 inline bool 474 operator!=(const complex<_Tp>& __x, const _Tp& __y) 475 { return __x.real() != __y || __x.imag() != _Tp(); } 476 477 template<typename _Tp> 478 inline bool 479 operator!=(const _Tp& __x, const complex<_Tp>& __y) 480 { return __x != __y.real() || _Tp() != __y.imag(); } 481 //@} 482 483 /// Extraction operator for complex values. 484 template<typename _Tp, typename _CharT, class _Traits> 485 basic_istream<_CharT, _Traits>& 486 operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x) 487 { 488 _Tp __re_x, __im_x; 489 _CharT __ch; 490 __is >> __ch; 491 if (__ch == '(') 492 { 493 __is >> __re_x >> __ch; 494 if (__ch == ',') 495 { 496 __is >> __im_x >> __ch; 497 if (__ch == ')') 498 __x = complex<_Tp>(__re_x, __im_x); 499 else 500 __is.setstate(ios_base::failbit); 501 } 502 else if (__ch == ')') 503 __x = __re_x; 504 else 505 __is.setstate(ios_base::failbit); 506 } 507 else 508 { 509 __is.putback(__ch); 510 __is >> __re_x; 511 __x = __re_x; 512 } 513 return __is; 514 } 515 516 /// Insertion operator for complex values. 517 template<typename _Tp, typename _CharT, class _Traits> 518 basic_ostream<_CharT, _Traits>& 519 operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x) 520 { 521 basic_ostringstream<_CharT, _Traits> __s; 522 __s.flags(__os.flags()); 523 __s.imbue(__os.getloc()); 524 __s.precision(__os.precision()); 525 __s << '(' << __x.real() << ',' << __x.imag() << ')'; 526 return __os << __s.str(); 527 } 528 529 // Values 530#ifdef __GXX_EXPERIMENTAL_CXX0X__ 531 template<typename _Tp> 532 inline _Tp 533 real(const complex<_Tp>& __z) 534 { return __z.real(); } 535 536 template<typename _Tp> 537 inline _Tp 538 imag(const complex<_Tp>& __z) 539 { return __z.imag(); } 540#else 541 template<typename _Tp> 542 inline _Tp& 543 real(complex<_Tp>& __z) 544 { return __z.real(); } 545 546 template<typename _Tp> 547 inline const _Tp& 548 real(const complex<_Tp>& __z) 549 { return __z.real(); } 550 551 template<typename _Tp> 552 inline _Tp& 553 imag(complex<_Tp>& __z) 554 { return __z.imag(); } 555 556 template<typename _Tp> 557 inline const _Tp& 558 imag(const complex<_Tp>& __z) 559 { return __z.imag(); } 560#endif 561 562 // 26.2.7/3 abs(__z): Returns the magnitude of __z. 563 template<typename _Tp> 564 inline _Tp 565 __complex_abs(const complex<_Tp>& __z) 566 { 567 _Tp __x = __z.real(); 568 _Tp __y = __z.imag(); 569 const _Tp __s = std::max(abs(__x), abs(__y)); 570 if (__s == _Tp()) // well ... 571 return __s; 572 __x /= __s; 573 __y /= __s; 574 return __s * sqrt(__x * __x + __y * __y); 575 } 576 577#if _GLIBCXX_USE_C99_COMPLEX 578 inline float 579 __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); } 580 581 inline double 582 __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); } 583 584 inline long double 585 __complex_abs(const __complex__ long double& __z) 586 { return __builtin_cabsl(__z); } 587 588 template<typename _Tp> 589 inline _Tp 590 abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); } 591#else 592 template<typename _Tp> 593 inline _Tp 594 abs(const complex<_Tp>& __z) { return __complex_abs(__z); } 595#endif 596 597 598 // 26.2.7/4: arg(__z): Returns the phase angle of __z. 599 template<typename _Tp> 600 inline _Tp 601 __complex_arg(const complex<_Tp>& __z) 602 { return atan2(__z.imag(), __z.real()); } 603 604#if _GLIBCXX_USE_C99_COMPLEX 605 inline float 606 __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); } 607 608 inline double 609 __complex_arg(__complex__ double __z) { return __builtin_carg(__z); } 610 611 inline long double 612 __complex_arg(const __complex__ long double& __z) 613 { return __builtin_cargl(__z); } 614 615 template<typename _Tp> 616 inline _Tp 617 arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); } 618#else 619 template<typename _Tp> 620 inline _Tp 621 arg(const complex<_Tp>& __z) { return __complex_arg(__z); } 622#endif 623 624 // 26.2.7/5: norm(__z) returns the squared magnitude of __z. 625 // As defined, norm() is -not- a norm is the common mathematical 626 // sens used in numerics. The helper class _Norm_helper<> tries to 627 // distinguish between builtin floating point and the rest, so as 628 // to deliver an answer as close as possible to the real value. 629 template<bool> 630 struct _Norm_helper 631 { 632 template<typename _Tp> 633 static inline _Tp _S_do_it(const complex<_Tp>& __z) 634 { 635 const _Tp __x = __z.real(); 636 const _Tp __y = __z.imag(); 637 return __x * __x + __y * __y; 638 } 639 }; 640 641 template<> 642 struct _Norm_helper<true> 643 { 644 template<typename _Tp> 645 static inline _Tp _S_do_it(const complex<_Tp>& __z) 646 { 647 _Tp __res = std::abs(__z); 648 return __res * __res; 649 } 650 }; 651 652 template<typename _Tp> 653 inline _Tp 654 norm(const complex<_Tp>& __z) 655 { 656 return _Norm_helper<__is_floating<_Tp>::__value 657 && !_GLIBCXX_FAST_MATH>::_S_do_it(__z); 658 } 659 660 template<typename _Tp> 661 inline complex<_Tp> 662 polar(const _Tp& __rho, const _Tp& __theta) 663 { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); } 664 665 template<typename _Tp> 666 inline complex<_Tp> 667 conj(const complex<_Tp>& __z) 668 { return complex<_Tp>(__z.real(), -__z.imag()); } 669 670 // Transcendentals 671 672 // 26.2.8/1 cos(__z): Returns the cosine of __z. 673 template<typename _Tp> 674 inline complex<_Tp> 675 __complex_cos(const complex<_Tp>& __z) 676 { 677 const _Tp __x = __z.real(); 678 const _Tp __y = __z.imag(); 679 return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y)); 680 } 681 682#if _GLIBCXX_USE_C99_COMPLEX 683 inline __complex__ float 684 __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); } 685 686 inline __complex__ double 687 __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); } 688 689 inline __complex__ long double 690 __complex_cos(const __complex__ long double& __z) 691 { return __builtin_ccosl(__z); } 692 693 template<typename _Tp> 694 inline complex<_Tp> 695 cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); } 696#else 697 template<typename _Tp> 698 inline complex<_Tp> 699 cos(const complex<_Tp>& __z) { return __complex_cos(__z); } 700#endif 701 702 // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z. 703 template<typename _Tp> 704 inline complex<_Tp> 705 __complex_cosh(const complex<_Tp>& __z) 706 { 707 const _Tp __x = __z.real(); 708 const _Tp __y = __z.imag(); 709 return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y)); 710 } 711 712#if _GLIBCXX_USE_C99_COMPLEX 713 inline __complex__ float 714 __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); } 715 716 inline __complex__ double 717 __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); } 718 719 inline __complex__ long double 720 __complex_cosh(const __complex__ long double& __z) 721 { return __builtin_ccoshl(__z); } 722 723 template<typename _Tp> 724 inline complex<_Tp> 725 cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); } 726#else 727 template<typename _Tp> 728 inline complex<_Tp> 729 cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); } 730#endif 731 732 // 26.2.8/3 exp(__z): Returns the complex base e exponential of x 733 template<typename _Tp> 734 inline complex<_Tp> 735 __complex_exp(const complex<_Tp>& __z) 736 { return std::polar(exp(__z.real()), __z.imag()); } 737 738#if _GLIBCXX_USE_C99_COMPLEX 739 inline __complex__ float 740 __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); } 741 742 inline __complex__ double 743 __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); } 744 745 inline __complex__ long double 746 __complex_exp(const __complex__ long double& __z) 747 { return __builtin_cexpl(__z); } 748 749 template<typename _Tp> 750 inline complex<_Tp> 751 exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); } 752#else 753 template<typename _Tp> 754 inline complex<_Tp> 755 exp(const complex<_Tp>& __z) { return __complex_exp(__z); } 756#endif 757 758 // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z. 759 // The branch cut is along the negative axis. 760 template<typename _Tp> 761 inline complex<_Tp> 762 __complex_log(const complex<_Tp>& __z) 763 { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); } 764 765#if _GLIBCXX_USE_C99_COMPLEX 766 inline __complex__ float 767 __complex_log(__complex__ float __z) { return __builtin_clogf(__z); } 768 769 inline __complex__ double 770 __complex_log(__complex__ double __z) { return __builtin_clog(__z); } 771 772 inline __complex__ long double 773 __complex_log(const __complex__ long double& __z) 774 { return __builtin_clogl(__z); } 775 776 template<typename _Tp> 777 inline complex<_Tp> 778 log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); } 779#else 780 template<typename _Tp> 781 inline complex<_Tp> 782 log(const complex<_Tp>& __z) { return __complex_log(__z); } 783#endif 784 785 template<typename _Tp> 786 inline complex<_Tp> 787 log10(const complex<_Tp>& __z) 788 { return std::log(__z) / log(_Tp(10.0)); } 789 790 // 26.2.8/10 sin(__z): Returns the sine of __z. 791 template<typename _Tp> 792 inline complex<_Tp> 793 __complex_sin(const complex<_Tp>& __z) 794 { 795 const _Tp __x = __z.real(); 796 const _Tp __y = __z.imag(); 797 return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y)); 798 } 799 800#if _GLIBCXX_USE_C99_COMPLEX 801 inline __complex__ float 802 __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); } 803 804 inline __complex__ double 805 __complex_sin(__complex__ double __z) { return __builtin_csin(__z); } 806 807 inline __complex__ long double 808 __complex_sin(const __complex__ long double& __z) 809 { return __builtin_csinl(__z); } 810 811 template<typename _Tp> 812 inline complex<_Tp> 813 sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); } 814#else 815 template<typename _Tp> 816 inline complex<_Tp> 817 sin(const complex<_Tp>& __z) { return __complex_sin(__z); } 818#endif 819 820 // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z. 821 template<typename _Tp> 822 inline complex<_Tp> 823 __complex_sinh(const complex<_Tp>& __z) 824 { 825 const _Tp __x = __z.real(); 826 const _Tp __y = __z.imag(); 827 return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y)); 828 } 829 830#if _GLIBCXX_USE_C99_COMPLEX 831 inline __complex__ float 832 __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); } 833 834 inline __complex__ double 835 __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); } 836 837 inline __complex__ long double 838 __complex_sinh(const __complex__ long double& __z) 839 { return __builtin_csinhl(__z); } 840 841 template<typename _Tp> 842 inline complex<_Tp> 843 sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); } 844#else 845 template<typename _Tp> 846 inline complex<_Tp> 847 sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); } 848#endif 849 850 // 26.2.8/13 sqrt(__z): Returns the complex square root of __z. 851 // The branch cut is on the negative axis. 852 template<typename _Tp> 853 complex<_Tp> 854 __complex_sqrt(const complex<_Tp>& __z) 855 { 856 _Tp __x = __z.real(); 857 _Tp __y = __z.imag(); 858 859 if (__x == _Tp()) 860 { 861 _Tp __t = sqrt(abs(__y) / 2); 862 return complex<_Tp>(__t, __y < _Tp() ? -__t : __t); 863 } 864 else 865 { 866 _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x))); 867 _Tp __u = __t / 2; 868 return __x > _Tp() 869 ? complex<_Tp>(__u, __y / __t) 870 : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u); 871 } 872 } 873 874#if _GLIBCXX_USE_C99_COMPLEX 875 inline __complex__ float 876 __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); } 877 878 inline __complex__ double 879 __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); } 880 881 inline __complex__ long double 882 __complex_sqrt(const __complex__ long double& __z) 883 { return __builtin_csqrtl(__z); } 884 885 template<typename _Tp> 886 inline complex<_Tp> 887 sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); } 888#else 889 template<typename _Tp> 890 inline complex<_Tp> 891 sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); } 892#endif 893 894 // 26.2.8/14 tan(__z): Return the complex tangent of __z. 895 896 template<typename _Tp> 897 inline complex<_Tp> 898 __complex_tan(const complex<_Tp>& __z) 899 { return std::sin(__z) / std::cos(__z); } 900 901#if _GLIBCXX_USE_C99_COMPLEX 902 inline __complex__ float 903 __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); } 904 905 inline __complex__ double 906 __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); } 907 908 inline __complex__ long double 909 __complex_tan(const __complex__ long double& __z) 910 { return __builtin_ctanl(__z); } 911 912 template<typename _Tp> 913 inline complex<_Tp> 914 tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); } 915#else 916 template<typename _Tp> 917 inline complex<_Tp> 918 tan(const complex<_Tp>& __z) { return __complex_tan(__z); } 919#endif 920 921 922 // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z. 923 924 template<typename _Tp> 925 inline complex<_Tp> 926 __complex_tanh(const complex<_Tp>& __z) 927 { return std::sinh(__z) / std::cosh(__z); } 928 929#if _GLIBCXX_USE_C99_COMPLEX 930 inline __complex__ float 931 __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); } 932 933 inline __complex__ double 934 __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); } 935 936 inline __complex__ long double 937 __complex_tanh(const __complex__ long double& __z) 938 { return __builtin_ctanhl(__z); } 939 940 template<typename _Tp> 941 inline complex<_Tp> 942 tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); } 943#else 944 template<typename _Tp> 945 inline complex<_Tp> 946 tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); } 947#endif 948 949 950 // 26.2.8/9 pow(__x, __y): Returns the complex power base of __x 951 // raised to the __y-th power. The branch 952 // cut is on the negative axis. 953#ifndef __GXX_EXPERIMENTAL_CXX0X__ 954 // _GLIBCXX_RESOLVE_LIB_DEFECTS 955 // DR 844. complex pow return type is ambiguous. 956 template<typename _Tp> 957 inline complex<_Tp> 958 pow(const complex<_Tp>& __z, int __n) 959 { return std::__pow_helper(__z, __n); } 960#endif 961 962 template<typename _Tp> 963 complex<_Tp> 964 pow(const complex<_Tp>& __x, const _Tp& __y) 965 { 966#ifndef _GLIBCXX_USE_C99_COMPLEX 967 if (__x == _Tp()) 968 return _Tp(); 969#endif 970 if (__x.imag() == _Tp() && __x.real() > _Tp()) 971 return pow(__x.real(), __y); 972 973 complex<_Tp> __t = std::log(__x); 974 return std::polar(exp(__y * __t.real()), __y * __t.imag()); 975 } 976 977 template<typename _Tp> 978 inline complex<_Tp> 979 __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y) 980 { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); } 981 982#if _GLIBCXX_USE_C99_COMPLEX 983 inline __complex__ float 984 __complex_pow(__complex__ float __x, __complex__ float __y) 985 { return __builtin_cpowf(__x, __y); } 986 987 inline __complex__ double 988 __complex_pow(__complex__ double __x, __complex__ double __y) 989 { return __builtin_cpow(__x, __y); } 990 991 inline __complex__ long double 992 __complex_pow(const __complex__ long double& __x, 993 const __complex__ long double& __y) 994 { return __builtin_cpowl(__x, __y); } 995 996 template<typename _Tp> 997 inline complex<_Tp> 998 pow(const complex<_Tp>& __x, const complex<_Tp>& __y) 999 { return __complex_pow(__x.__rep(), __y.__rep()); } 1000#else 1001 template<typename _Tp> 1002 inline complex<_Tp> 1003 pow(const complex<_Tp>& __x, const complex<_Tp>& __y) 1004 { return __complex_pow(__x, __y); } 1005#endif 1006 1007 template<typename _Tp> 1008 inline complex<_Tp> 1009 pow(const _Tp& __x, const complex<_Tp>& __y) 1010 { 1011 return __x > _Tp() ? std::polar(pow(__x, __y.real()), 1012 __y.imag() * log(__x)) 1013 : std::pow(complex<_Tp>(__x), __y); 1014 } 1015 1016 // 26.2.3 complex specializations 1017 // complex<float> specialization 1018 template<> 1019 struct complex<float> 1020 { 1021 typedef float value_type; 1022 typedef __complex__ float _ComplexT; 1023 1024 complex(_ComplexT __z) : _M_value(__z) { } 1025 1026 complex(float __r = 0.0f, float __i = 0.0f) 1027 { 1028 __real__ _M_value = __r; 1029 __imag__ _M_value = __i; 1030 } 1031 1032 explicit complex(const complex<double>&); 1033 explicit complex(const complex<long double>&); 1034 1035#ifdef __GXX_EXPERIMENTAL_CXX0X__ 1036 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1037 // DR 387. std::complex over-encapsulated. 1038 float real() const 1039 { return __real__ _M_value; } 1040 1041 float imag() const 1042 { return __imag__ _M_value; } 1043#else 1044 float& real() 1045 { return __real__ _M_value; } 1046 1047 const float& real() const 1048 { return __real__ _M_value; } 1049 1050 float& imag() 1051 { return __imag__ _M_value; } 1052 1053 const float& imag() const 1054 { return __imag__ _M_value; } 1055#endif 1056 1057 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1058 // DR 387. std::complex over-encapsulated. 1059 void real(float __val) 1060 { __real__ _M_value = __val; } 1061 1062 void imag(float __val) 1063 { __imag__ _M_value = __val; } 1064 1065 complex<float>& 1066 operator=(float __f) 1067 { 1068 __real__ _M_value = __f; 1069 __imag__ _M_value = 0.0f; 1070 return *this; 1071 } 1072 1073 complex<float>& 1074 operator+=(float __f) 1075 { 1076 __real__ _M_value += __f; 1077 return *this; 1078 } 1079 1080 complex<float>& 1081 operator-=(float __f) 1082 { 1083 __real__ _M_value -= __f; 1084 return *this; 1085 } 1086 1087 complex<float>& 1088 operator*=(float __f) 1089 { 1090 _M_value *= __f; 1091 return *this; 1092 } 1093 1094 complex<float>& 1095 operator/=(float __f) 1096 { 1097 _M_value /= __f; 1098 return *this; 1099 } 1100 1101 // Let the compiler synthesize the copy and assignment 1102 // operator. It always does a pretty good job. 1103 // complex& operator=(const complex&); 1104 1105 template<typename _Tp> 1106 complex<float>& 1107 operator=(const complex<_Tp>& __z) 1108 { 1109 __real__ _M_value = __z.real(); 1110 __imag__ _M_value = __z.imag(); 1111 return *this; 1112 } 1113 1114 template<typename _Tp> 1115 complex<float>& 1116 operator+=(const complex<_Tp>& __z) 1117 { 1118 __real__ _M_value += __z.real(); 1119 __imag__ _M_value += __z.imag(); 1120 return *this; 1121 } 1122 1123 template<class _Tp> 1124 complex<float>& 1125 operator-=(const complex<_Tp>& __z) 1126 { 1127 __real__ _M_value -= __z.real(); 1128 __imag__ _M_value -= __z.imag(); 1129 return *this; 1130 } 1131 1132 template<class _Tp> 1133 complex<float>& 1134 operator*=(const complex<_Tp>& __z) 1135 { 1136 _ComplexT __t; 1137 __real__ __t = __z.real(); 1138 __imag__ __t = __z.imag(); 1139 _M_value *= __t; 1140 return *this; 1141 } 1142 1143 template<class _Tp> 1144 complex<float>& 1145 operator/=(const complex<_Tp>& __z) 1146 { 1147 _ComplexT __t; 1148 __real__ __t = __z.real(); 1149 __imag__ __t = __z.imag(); 1150 _M_value /= __t; 1151 return *this; 1152 } 1153 1154 const _ComplexT& __rep() const { return _M_value; } 1155 1156 private: 1157 _ComplexT _M_value; 1158 }; 1159 1160 // 26.2.3 complex specializations 1161 // complex<double> specialization 1162 template<> 1163 struct complex<double> 1164 { 1165 typedef double value_type; 1166 typedef __complex__ double _ComplexT; 1167 1168 complex(_ComplexT __z) : _M_value(__z) { } 1169 1170 complex(double __r = 0.0, double __i = 0.0) 1171 { 1172 __real__ _M_value = __r; 1173 __imag__ _M_value = __i; 1174 } 1175 1176 complex(const complex<float>& __z) 1177 : _M_value(__z.__rep()) { } 1178 1179 explicit complex(const complex<long double>&); 1180 1181#ifdef __GXX_EXPERIMENTAL_CXX0X__ 1182 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1183 // DR 387. std::complex over-encapsulated. 1184 double real() const 1185 { return __real__ _M_value; } 1186 1187 double imag() const 1188 { return __imag__ _M_value; } 1189#else 1190 double& real() 1191 { return __real__ _M_value; } 1192 1193 const double& real() const 1194 { return __real__ _M_value; } 1195 1196 double& imag() 1197 { return __imag__ _M_value; } 1198 1199 const double& imag() const 1200 { return __imag__ _M_value; } 1201#endif 1202 1203 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1204 // DR 387. std::complex over-encapsulated. 1205 void real(double __val) 1206 { __real__ _M_value = __val; } 1207 1208 void imag(double __val) 1209 { __imag__ _M_value = __val; } 1210 1211 complex<double>& 1212 operator=(double __d) 1213 { 1214 __real__ _M_value = __d; 1215 __imag__ _M_value = 0.0; 1216 return *this; 1217 } 1218 1219 complex<double>& 1220 operator+=(double __d) 1221 { 1222 __real__ _M_value += __d; 1223 return *this; 1224 } 1225 1226 complex<double>& 1227 operator-=(double __d) 1228 { 1229 __real__ _M_value -= __d; 1230 return *this; 1231 } 1232 1233 complex<double>& 1234 operator*=(double __d) 1235 { 1236 _M_value *= __d; 1237 return *this; 1238 } 1239 1240 complex<double>& 1241 operator/=(double __d) 1242 { 1243 _M_value /= __d; 1244 return *this; 1245 } 1246 1247 // The compiler will synthesize this, efficiently. 1248 // complex& operator=(const complex&); 1249 1250 template<typename _Tp> 1251 complex<double>& 1252 operator=(const complex<_Tp>& __z) 1253 { 1254 __real__ _M_value = __z.real(); 1255 __imag__ _M_value = __z.imag(); 1256 return *this; 1257 } 1258 1259 template<typename _Tp> 1260 complex<double>& 1261 operator+=(const complex<_Tp>& __z) 1262 { 1263 __real__ _M_value += __z.real(); 1264 __imag__ _M_value += __z.imag(); 1265 return *this; 1266 } 1267 1268 template<typename _Tp> 1269 complex<double>& 1270 operator-=(const complex<_Tp>& __z) 1271 { 1272 __real__ _M_value -= __z.real(); 1273 __imag__ _M_value -= __z.imag(); 1274 return *this; 1275 } 1276 1277 template<typename _Tp> 1278 complex<double>& 1279 operator*=(const complex<_Tp>& __z) 1280 { 1281 _ComplexT __t; 1282 __real__ __t = __z.real(); 1283 __imag__ __t = __z.imag(); 1284 _M_value *= __t; 1285 return *this; 1286 } 1287 1288 template<typename _Tp> 1289 complex<double>& 1290 operator/=(const complex<_Tp>& __z) 1291 { 1292 _ComplexT __t; 1293 __real__ __t = __z.real(); 1294 __imag__ __t = __z.imag(); 1295 _M_value /= __t; 1296 return *this; 1297 } 1298 1299 const _ComplexT& __rep() const { return _M_value; } 1300 1301 private: 1302 _ComplexT _M_value; 1303 }; 1304 1305 // 26.2.3 complex specializations 1306 // complex<long double> specialization 1307 template<> 1308 struct complex<long double> 1309 { 1310 typedef long double value_type; 1311 typedef __complex__ long double _ComplexT; 1312 1313 complex(_ComplexT __z) : _M_value(__z) { } 1314 1315 complex(long double __r = 0.0L, long double __i = 0.0L) 1316 { 1317 __real__ _M_value = __r; 1318 __imag__ _M_value = __i; 1319 } 1320 1321 complex(const complex<float>& __z) 1322 : _M_value(__z.__rep()) { } 1323 1324 complex(const complex<double>& __z) 1325 : _M_value(__z.__rep()) { } 1326 1327#ifdef __GXX_EXPERIMENTAL_CXX0X__ 1328 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1329 // DR 387. std::complex over-encapsulated. 1330 long double real() const 1331 { return __real__ _M_value; } 1332 1333 long double imag() const 1334 { return __imag__ _M_value; } 1335#else 1336 long double& real() 1337 { return __real__ _M_value; } 1338 1339 const long double& real() const 1340 { return __real__ _M_value; } 1341 1342 long double& imag() 1343 { return __imag__ _M_value; } 1344 1345 const long double& imag() const 1346 { return __imag__ _M_value; } 1347#endif 1348 1349 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1350 // DR 387. std::complex over-encapsulated. 1351 void real(long double __val) 1352 { __real__ _M_value = __val; } 1353 1354 void imag(long double __val) 1355 { __imag__ _M_value = __val; } 1356 1357 complex<long double>& 1358 operator=(long double __r) 1359 { 1360 __real__ _M_value = __r; 1361 __imag__ _M_value = 0.0L; 1362 return *this; 1363 } 1364 1365 complex<long double>& 1366 operator+=(long double __r) 1367 { 1368 __real__ _M_value += __r; 1369 return *this; 1370 } 1371 1372 complex<long double>& 1373 operator-=(long double __r) 1374 { 1375 __real__ _M_value -= __r; 1376 return *this; 1377 } 1378 1379 complex<long double>& 1380 operator*=(long double __r) 1381 { 1382 _M_value *= __r; 1383 return *this; 1384 } 1385 1386 complex<long double>& 1387 operator/=(long double __r) 1388 { 1389 _M_value /= __r; 1390 return *this; 1391 } 1392 1393 // The compiler knows how to do this efficiently 1394 // complex& operator=(const complex&); 1395 1396 template<typename _Tp> 1397 complex<long double>& 1398 operator=(const complex<_Tp>& __z) 1399 { 1400 __real__ _M_value = __z.real(); 1401 __imag__ _M_value = __z.imag(); 1402 return *this; 1403 } 1404 1405 template<typename _Tp> 1406 complex<long double>& 1407 operator+=(const complex<_Tp>& __z) 1408 { 1409 __real__ _M_value += __z.real(); 1410 __imag__ _M_value += __z.imag(); 1411 return *this; 1412 } 1413 1414 template<typename _Tp> 1415 complex<long double>& 1416 operator-=(const complex<_Tp>& __z) 1417 { 1418 __real__ _M_value -= __z.real(); 1419 __imag__ _M_value -= __z.imag(); 1420 return *this; 1421 } 1422 1423 template<typename _Tp> 1424 complex<long double>& 1425 operator*=(const complex<_Tp>& __z) 1426 { 1427 _ComplexT __t; 1428 __real__ __t = __z.real(); 1429 __imag__ __t = __z.imag(); 1430 _M_value *= __t; 1431 return *this; 1432 } 1433 1434 template<typename _Tp> 1435 complex<long double>& 1436 operator/=(const complex<_Tp>& __z) 1437 { 1438 _ComplexT __t; 1439 __real__ __t = __z.real(); 1440 __imag__ __t = __z.imag(); 1441 _M_value /= __t; 1442 return *this; 1443 } 1444 1445 const _ComplexT& __rep() const { return _M_value; } 1446 1447 private: 1448 _ComplexT _M_value; 1449 }; 1450 1451 // These bits have to be at the end of this file, so that the 1452 // specializations have all been defined. 1453 inline 1454 complex<float>::complex(const complex<double>& __z) 1455 : _M_value(__z.__rep()) { } 1456 1457 inline 1458 complex<float>::complex(const complex<long double>& __z) 1459 : _M_value(__z.__rep()) { } 1460 1461 inline 1462 complex<double>::complex(const complex<long double>& __z) 1463 : _M_value(__z.__rep()) { } 1464 1465 // Inhibit implicit instantiations for required instantiations, 1466 // which are defined via explicit instantiations elsewhere. 1467 // NB: This syntax is a GNU extension. 1468#if _GLIBCXX_EXTERN_TEMPLATE 1469 extern template istream& operator>>(istream&, complex<float>&); 1470 extern template ostream& operator<<(ostream&, const complex<float>&); 1471 extern template istream& operator>>(istream&, complex<double>&); 1472 extern template ostream& operator<<(ostream&, const complex<double>&); 1473 extern template istream& operator>>(istream&, complex<long double>&); 1474 extern template ostream& operator<<(ostream&, const complex<long double>&); 1475 1476#ifdef _GLIBCXX_USE_WCHAR_T 1477 extern template wistream& operator>>(wistream&, complex<float>&); 1478 extern template wostream& operator<<(wostream&, const complex<float>&); 1479 extern template wistream& operator>>(wistream&, complex<double>&); 1480 extern template wostream& operator<<(wostream&, const complex<double>&); 1481 extern template wistream& operator>>(wistream&, complex<long double>&); 1482 extern template wostream& operator<<(wostream&, const complex<long double>&); 1483#endif 1484#endif 1485 1486 // @} group complex_numbers 1487 1488_GLIBCXX_END_NAMESPACE 1489 1490_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) 1491 1492 // See ext/type_traits.h for the primary template. 1493 template<typename _Tp, typename _Up> 1494 struct __promote_2<std::complex<_Tp>, _Up> 1495 { 1496 public: 1497 typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type; 1498 }; 1499 1500 template<typename _Tp, typename _Up> 1501 struct __promote_2<_Tp, std::complex<_Up> > 1502 { 1503 public: 1504 typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type; 1505 }; 1506 1507 template<typename _Tp, typename _Up> 1508 struct __promote_2<std::complex<_Tp>, std::complex<_Up> > 1509 { 1510 public: 1511 typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type; 1512 }; 1513 1514_GLIBCXX_END_NAMESPACE 1515 1516#ifdef __GXX_EXPERIMENTAL_CXX0X__ 1517# if defined(_GLIBCXX_INCLUDE_AS_TR1) 1518# error C++0x header cannot be included from TR1 header 1519# endif 1520# if defined(_GLIBCXX_INCLUDE_AS_CXX0X) 1521# include <tr1_impl/complex> 1522# else 1523# define _GLIBCXX_INCLUDE_AS_CXX0X 1524# define _GLIBCXX_BEGIN_NAMESPACE_TR1 1525# define _GLIBCXX_END_NAMESPACE_TR1 1526# define _GLIBCXX_TR1 1527# include <tr1_impl/complex> 1528# undef _GLIBCXX_TR1 1529# undef _GLIBCXX_END_NAMESPACE_TR1 1530# undef _GLIBCXX_BEGIN_NAMESPACE_TR1 1531# undef _GLIBCXX_INCLUDE_AS_CXX0X 1532# endif 1533 1534_GLIBCXX_BEGIN_NAMESPACE(std) 1535 1536 // Forward declarations. 1537 // DR 781. 1538 template<typename _Tp> std::complex<_Tp> proj(const std::complex<_Tp>&); 1539 1540 template<typename _Tp> 1541 std::complex<_Tp> 1542 __complex_proj(const std::complex<_Tp>& __z) 1543 { 1544 const _Tp __den = (__z.real() * __z.real() 1545 + __z.imag() * __z.imag() + _Tp(1.0)); 1546 1547 return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den, 1548 (_Tp(2.0) * __z.imag()) / __den); 1549 } 1550 1551#if _GLIBCXX_USE_C99_COMPLEX 1552 inline __complex__ float 1553 __complex_proj(__complex__ float __z) 1554 { return __builtin_cprojf(__z); } 1555 1556 inline __complex__ double 1557 __complex_proj(__complex__ double __z) 1558 { return __builtin_cproj(__z); } 1559 1560 inline __complex__ long double 1561 __complex_proj(const __complex__ long double& __z) 1562 { return __builtin_cprojl(__z); } 1563 1564 template<typename _Tp> 1565 inline std::complex<_Tp> 1566 proj(const std::complex<_Tp>& __z) 1567 { return __complex_proj(__z.__rep()); } 1568#else 1569 template<typename _Tp> 1570 inline std::complex<_Tp> 1571 proj(const std::complex<_Tp>& __z) 1572 { return __complex_proj(__z); } 1573#endif 1574 1575 // DR 1137. 1576 template<typename _Tp> 1577 inline typename __gnu_cxx::__promote<_Tp>::__type 1578 proj(_Tp __x) 1579 { return __x; } 1580 1581 template<typename _Tp> 1582 inline typename __gnu_cxx::__promote<_Tp>::__type 1583 conj(_Tp __x) 1584 { return __x; } 1585 1586_GLIBCXX_END_NAMESPACE 1587 1588#endif 1589 1590#endif /* _GLIBCXX_COMPLEX */ 1591