00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038 #ifndef _GLIBCXX_COMPLEX
00039 #define _GLIBCXX_COMPLEX 1
00040
00041 #pragma GCC system_header
00042
00043 #include <bits/c++config.h>
00044 #include <bits/cpp_type_traits.h>
00045 #include <ext/type_traits.h>
00046 #include <cmath>
00047 #include <sstream>
00048
00049 _GLIBCXX_BEGIN_NAMESPACE(std)
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060 template<typename _Tp> class complex;
00061 template<> class complex<float>;
00062 template<> class complex<double>;
00063 template<> class complex<long double>;
00064
00065
00066 template<typename _Tp> _Tp abs(const complex<_Tp>&);
00067
00068 template<typename _Tp> _Tp arg(const complex<_Tp>&);
00069
00070 template<typename _Tp> _Tp norm(const complex<_Tp>&);
00071
00072
00073 template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
00074
00075 template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
00076
00077
00078
00079 template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
00080
00081 template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
00082
00083 template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
00084
00085 template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
00086
00087 template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
00088 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00089
00090
00091 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
00092 #endif
00093
00094 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
00095
00096 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
00097 const complex<_Tp>&);
00098
00099 template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
00100
00101 template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
00102
00103 template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
00104
00105 template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
00106
00107 template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
00108
00109 template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121 template<typename _Tp>
00122 struct complex
00123 {
00124
00125 typedef _Tp value_type;
00126
00127
00128
00129 complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
00130 : _M_real(__r), _M_imag(__i) { }
00131
00132
00133
00134
00135 template<typename _Up>
00136 complex(const complex<_Up>& __z)
00137 : _M_real(__z.real()), _M_imag(__z.imag()) { }
00138
00139 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00140
00141
00142 _Tp real() const
00143 { return _M_real; }
00144
00145 _Tp imag() const
00146 { return _M_imag; }
00147 #else
00148
00149 _Tp& real()
00150 { return _M_real; }
00151
00152
00153 const _Tp& real() const
00154 { return _M_real; }
00155
00156
00157 _Tp& imag()
00158 { return _M_imag; }
00159
00160
00161 const _Tp& imag() const
00162 { return _M_imag; }
00163 #endif
00164
00165
00166
00167 void real(_Tp __val)
00168 { _M_real = __val; }
00169
00170 void imag(_Tp __val)
00171 { _M_imag = __val; }
00172
00173
00174 complex<_Tp>& operator=(const _Tp&);
00175
00176
00177
00178 complex<_Tp>&
00179 operator+=(const _Tp& __t)
00180 {
00181 _M_real += __t;
00182 return *this;
00183 }
00184
00185
00186
00187 complex<_Tp>&
00188 operator-=(const _Tp& __t)
00189 {
00190 _M_real -= __t;
00191 return *this;
00192 }
00193
00194
00195 complex<_Tp>& operator*=(const _Tp&);
00196
00197 complex<_Tp>& operator/=(const _Tp&);
00198
00199
00200
00201
00202
00203 template<typename _Up>
00204 complex<_Tp>& operator=(const complex<_Up>&);
00205
00206 template<typename _Up>
00207 complex<_Tp>& operator+=(const complex<_Up>&);
00208
00209 template<typename _Up>
00210 complex<_Tp>& operator-=(const complex<_Up>&);
00211
00212 template<typename _Up>
00213 complex<_Tp>& operator*=(const complex<_Up>&);
00214
00215 template<typename _Up>
00216 complex<_Tp>& operator/=(const complex<_Up>&);
00217
00218 const complex& __rep() const
00219 { return *this; }
00220
00221 private:
00222 _Tp _M_real;
00223 _Tp _M_imag;
00224 };
00225
00226 template<typename _Tp>
00227 complex<_Tp>&
00228 complex<_Tp>::operator=(const _Tp& __t)
00229 {
00230 _M_real = __t;
00231 _M_imag = _Tp();
00232 return *this;
00233 }
00234
00235
00236 template<typename _Tp>
00237 complex<_Tp>&
00238 complex<_Tp>::operator*=(const _Tp& __t)
00239 {
00240 _M_real *= __t;
00241 _M_imag *= __t;
00242 return *this;
00243 }
00244
00245
00246 template<typename _Tp>
00247 complex<_Tp>&
00248 complex<_Tp>::operator/=(const _Tp& __t)
00249 {
00250 _M_real /= __t;
00251 _M_imag /= __t;
00252 return *this;
00253 }
00254
00255 template<typename _Tp>
00256 template<typename _Up>
00257 complex<_Tp>&
00258 complex<_Tp>::operator=(const complex<_Up>& __z)
00259 {
00260 _M_real = __z.real();
00261 _M_imag = __z.imag();
00262 return *this;
00263 }
00264
00265
00266 template<typename _Tp>
00267 template<typename _Up>
00268 complex<_Tp>&
00269 complex<_Tp>::operator+=(const complex<_Up>& __z)
00270 {
00271 _M_real += __z.real();
00272 _M_imag += __z.imag();
00273 return *this;
00274 }
00275
00276
00277 template<typename _Tp>
00278 template<typename _Up>
00279 complex<_Tp>&
00280 complex<_Tp>::operator-=(const complex<_Up>& __z)
00281 {
00282 _M_real -= __z.real();
00283 _M_imag -= __z.imag();
00284 return *this;
00285 }
00286
00287
00288
00289 template<typename _Tp>
00290 template<typename _Up>
00291 complex<_Tp>&
00292 complex<_Tp>::operator*=(const complex<_Up>& __z)
00293 {
00294 const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
00295 _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
00296 _M_real = __r;
00297 return *this;
00298 }
00299
00300
00301
00302 template<typename _Tp>
00303 template<typename _Up>
00304 complex<_Tp>&
00305 complex<_Tp>::operator/=(const complex<_Up>& __z)
00306 {
00307 const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
00308 const _Tp __n = std::norm(__z);
00309 _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
00310 _M_real = __r / __n;
00311 return *this;
00312 }
00313
00314
00315
00316
00317 template<typename _Tp>
00318 inline complex<_Tp>
00319 operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
00320 {
00321 complex<_Tp> __r = __x;
00322 __r += __y;
00323 return __r;
00324 }
00325
00326 template<typename _Tp>
00327 inline complex<_Tp>
00328 operator+(const complex<_Tp>& __x, const _Tp& __y)
00329 {
00330 complex<_Tp> __r = __x;
00331 __r += __y;
00332 return __r;
00333 }
00334
00335 template<typename _Tp>
00336 inline complex<_Tp>
00337 operator+(const _Tp& __x, const complex<_Tp>& __y)
00338 {
00339 complex<_Tp> __r = __y;
00340 __r += __x;
00341 return __r;
00342 }
00343
00344
00345
00346
00347 template<typename _Tp>
00348 inline complex<_Tp>
00349 operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
00350 {
00351 complex<_Tp> __r = __x;
00352 __r -= __y;
00353 return __r;
00354 }
00355
00356 template<typename _Tp>
00357 inline complex<_Tp>
00358 operator-(const complex<_Tp>& __x, const _Tp& __y)
00359 {
00360 complex<_Tp> __r = __x;
00361 __r -= __y;
00362 return __r;
00363 }
00364
00365 template<typename _Tp>
00366 inline complex<_Tp>
00367 operator-(const _Tp& __x, const complex<_Tp>& __y)
00368 {
00369 complex<_Tp> __r(__x, -__y.imag());
00370 __r -= __y.real();
00371 return __r;
00372 }
00373
00374
00375
00376
00377 template<typename _Tp>
00378 inline complex<_Tp>
00379 operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
00380 {
00381 complex<_Tp> __r = __x;
00382 __r *= __y;
00383 return __r;
00384 }
00385
00386 template<typename _Tp>
00387 inline complex<_Tp>
00388 operator*(const complex<_Tp>& __x, const _Tp& __y)
00389 {
00390 complex<_Tp> __r = __x;
00391 __r *= __y;
00392 return __r;
00393 }
00394
00395 template<typename _Tp>
00396 inline complex<_Tp>
00397 operator*(const _Tp& __x, const complex<_Tp>& __y)
00398 {
00399 complex<_Tp> __r = __y;
00400 __r *= __x;
00401 return __r;
00402 }
00403
00404
00405
00406
00407 template<typename _Tp>
00408 inline complex<_Tp>
00409 operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
00410 {
00411 complex<_Tp> __r = __x;
00412 __r /= __y;
00413 return __r;
00414 }
00415
00416 template<typename _Tp>
00417 inline complex<_Tp>
00418 operator/(const complex<_Tp>& __x, const _Tp& __y)
00419 {
00420 complex<_Tp> __r = __x;
00421 __r /= __y;
00422 return __r;
00423 }
00424
00425 template<typename _Tp>
00426 inline complex<_Tp>
00427 operator/(const _Tp& __x, const complex<_Tp>& __y)
00428 {
00429 complex<_Tp> __r = __x;
00430 __r /= __y;
00431 return __r;
00432 }
00433
00434
00435
00436 template<typename _Tp>
00437 inline complex<_Tp>
00438 operator+(const complex<_Tp>& __x)
00439 { return __x; }
00440
00441
00442 template<typename _Tp>
00443 inline complex<_Tp>
00444 operator-(const complex<_Tp>& __x)
00445 { return complex<_Tp>(-__x.real(), -__x.imag()); }
00446
00447
00448
00449 template<typename _Tp>
00450 inline bool
00451 operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
00452 { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
00453
00454 template<typename _Tp>
00455 inline bool
00456 operator==(const complex<_Tp>& __x, const _Tp& __y)
00457 { return __x.real() == __y && __x.imag() == _Tp(); }
00458
00459 template<typename _Tp>
00460 inline bool
00461 operator==(const _Tp& __x, const complex<_Tp>& __y)
00462 { return __x == __y.real() && _Tp() == __y.imag(); }
00463
00464
00465
00466
00467 template<typename _Tp>
00468 inline bool
00469 operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
00470 { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
00471
00472 template<typename _Tp>
00473 inline bool
00474 operator!=(const complex<_Tp>& __x, const _Tp& __y)
00475 { return __x.real() != __y || __x.imag() != _Tp(); }
00476
00477 template<typename _Tp>
00478 inline bool
00479 operator!=(const _Tp& __x, const complex<_Tp>& __y)
00480 { return __x != __y.real() || _Tp() != __y.imag(); }
00481
00482
00483
00484 template<typename _Tp, typename _CharT, class _Traits>
00485 basic_istream<_CharT, _Traits>&
00486 operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
00487 {
00488 _Tp __re_x, __im_x;
00489 _CharT __ch;
00490 __is >> __ch;
00491 if (__ch == '(')
00492 {
00493 __is >> __re_x >> __ch;
00494 if (__ch == ',')
00495 {
00496 __is >> __im_x >> __ch;
00497 if (__ch == ')')
00498 __x = complex<_Tp>(__re_x, __im_x);
00499 else
00500 __is.setstate(ios_base::failbit);
00501 }
00502 else if (__ch == ')')
00503 __x = __re_x;
00504 else
00505 __is.setstate(ios_base::failbit);
00506 }
00507 else
00508 {
00509 __is.putback(__ch);
00510 __is >> __re_x;
00511 __x = __re_x;
00512 }
00513 return __is;
00514 }
00515
00516
00517 template<typename _Tp, typename _CharT, class _Traits>
00518 basic_ostream<_CharT, _Traits>&
00519 operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
00520 {
00521 basic_ostringstream<_CharT, _Traits> __s;
00522 __s.flags(__os.flags());
00523 __s.imbue(__os.getloc());
00524 __s.precision(__os.precision());
00525 __s << '(' << __x.real() << ',' << __x.imag() << ')';
00526 return __os << __s.str();
00527 }
00528
00529
00530 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00531 template<typename _Tp>
00532 inline _Tp
00533 real(const complex<_Tp>& __z)
00534 { return __z.real(); }
00535
00536 template<typename _Tp>
00537 inline _Tp
00538 imag(const complex<_Tp>& __z)
00539 { return __z.imag(); }
00540 #else
00541 template<typename _Tp>
00542 inline _Tp&
00543 real(complex<_Tp>& __z)
00544 { return __z.real(); }
00545
00546 template<typename _Tp>
00547 inline const _Tp&
00548 real(const complex<_Tp>& __z)
00549 { return __z.real(); }
00550
00551 template<typename _Tp>
00552 inline _Tp&
00553 imag(complex<_Tp>& __z)
00554 { return __z.imag(); }
00555
00556 template<typename _Tp>
00557 inline const _Tp&
00558 imag(const complex<_Tp>& __z)
00559 { return __z.imag(); }
00560 #endif
00561
00562
00563 template<typename _Tp>
00564 inline _Tp
00565 __complex_abs(const complex<_Tp>& __z)
00566 {
00567 _Tp __x = __z.real();
00568 _Tp __y = __z.imag();
00569 const _Tp __s = std::max(abs(__x), abs(__y));
00570 if (__s == _Tp())
00571 return __s;
00572 __x /= __s;
00573 __y /= __s;
00574 return __s * sqrt(__x * __x + __y * __y);
00575 }
00576
00577 #if _GLIBCXX_USE_C99_COMPLEX
00578 inline float
00579 __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
00580
00581 inline double
00582 __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
00583
00584 inline long double
00585 __complex_abs(const __complex__ long double& __z)
00586 { return __builtin_cabsl(__z); }
00587
00588 template<typename _Tp>
00589 inline _Tp
00590 abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
00591 #else
00592 template<typename _Tp>
00593 inline _Tp
00594 abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
00595 #endif
00596
00597
00598
00599 template<typename _Tp>
00600 inline _Tp
00601 __complex_arg(const complex<_Tp>& __z)
00602 { return atan2(__z.imag(), __z.real()); }
00603
00604 #if _GLIBCXX_USE_C99_COMPLEX
00605 inline float
00606 __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
00607
00608 inline double
00609 __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
00610
00611 inline long double
00612 __complex_arg(const __complex__ long double& __z)
00613 { return __builtin_cargl(__z); }
00614
00615 template<typename _Tp>
00616 inline _Tp
00617 arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
00618 #else
00619 template<typename _Tp>
00620 inline _Tp
00621 arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
00622 #endif
00623
00624
00625
00626
00627
00628
00629 template<bool>
00630 struct _Norm_helper
00631 {
00632 template<typename _Tp>
00633 static inline _Tp _S_do_it(const complex<_Tp>& __z)
00634 {
00635 const _Tp __x = __z.real();
00636 const _Tp __y = __z.imag();
00637 return __x * __x + __y * __y;
00638 }
00639 };
00640
00641 template<>
00642 struct _Norm_helper<true>
00643 {
00644 template<typename _Tp>
00645 static inline _Tp _S_do_it(const complex<_Tp>& __z)
00646 {
00647 _Tp __res = std::abs(__z);
00648 return __res * __res;
00649 }
00650 };
00651
00652 template<typename _Tp>
00653 inline _Tp
00654 norm(const complex<_Tp>& __z)
00655 {
00656 return _Norm_helper<__is_floating<_Tp>::__value
00657 && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
00658 }
00659
00660 template<typename _Tp>
00661 inline complex<_Tp>
00662 polar(const _Tp& __rho, const _Tp& __theta)
00663 { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
00664
00665 template<typename _Tp>
00666 inline complex<_Tp>
00667 conj(const complex<_Tp>& __z)
00668 { return complex<_Tp>(__z.real(), -__z.imag()); }
00669
00670
00671
00672
00673 template<typename _Tp>
00674 inline complex<_Tp>
00675 __complex_cos(const complex<_Tp>& __z)
00676 {
00677 const _Tp __x = __z.real();
00678 const _Tp __y = __z.imag();
00679 return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
00680 }
00681
00682 #if _GLIBCXX_USE_C99_COMPLEX
00683 inline __complex__ float
00684 __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
00685
00686 inline __complex__ double
00687 __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
00688
00689 inline __complex__ long double
00690 __complex_cos(const __complex__ long double& __z)
00691 { return __builtin_ccosl(__z); }
00692
00693 template<typename _Tp>
00694 inline complex<_Tp>
00695 cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
00696 #else
00697 template<typename _Tp>
00698 inline complex<_Tp>
00699 cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
00700 #endif
00701
00702
00703 template<typename _Tp>
00704 inline complex<_Tp>
00705 __complex_cosh(const complex<_Tp>& __z)
00706 {
00707 const _Tp __x = __z.real();
00708 const _Tp __y = __z.imag();
00709 return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
00710 }
00711
00712 #if _GLIBCXX_USE_C99_COMPLEX
00713 inline __complex__ float
00714 __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
00715
00716 inline __complex__ double
00717 __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
00718
00719 inline __complex__ long double
00720 __complex_cosh(const __complex__ long double& __z)
00721 { return __builtin_ccoshl(__z); }
00722
00723 template<typename _Tp>
00724 inline complex<_Tp>
00725 cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
00726 #else
00727 template<typename _Tp>
00728 inline complex<_Tp>
00729 cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
00730 #endif
00731
00732
00733 template<typename _Tp>
00734 inline complex<_Tp>
00735 __complex_exp(const complex<_Tp>& __z)
00736 { return std::polar(exp(__z.real()), __z.imag()); }
00737
00738 #if _GLIBCXX_USE_C99_COMPLEX
00739 inline __complex__ float
00740 __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
00741
00742 inline __complex__ double
00743 __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
00744
00745 inline __complex__ long double
00746 __complex_exp(const __complex__ long double& __z)
00747 { return __builtin_cexpl(__z); }
00748
00749 template<typename _Tp>
00750 inline complex<_Tp>
00751 exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
00752 #else
00753 template<typename _Tp>
00754 inline complex<_Tp>
00755 exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
00756 #endif
00757
00758
00759
00760 template<typename _Tp>
00761 inline complex<_Tp>
00762 __complex_log(const complex<_Tp>& __z)
00763 { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
00764
00765 #if _GLIBCXX_USE_C99_COMPLEX
00766 inline __complex__ float
00767 __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
00768
00769 inline __complex__ double
00770 __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
00771
00772 inline __complex__ long double
00773 __complex_log(const __complex__ long double& __z)
00774 { return __builtin_clogl(__z); }
00775
00776 template<typename _Tp>
00777 inline complex<_Tp>
00778 log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
00779 #else
00780 template<typename _Tp>
00781 inline complex<_Tp>
00782 log(const complex<_Tp>& __z) { return __complex_log(__z); }
00783 #endif
00784
00785 template<typename _Tp>
00786 inline complex<_Tp>
00787 log10(const complex<_Tp>& __z)
00788 { return std::log(__z) / log(_Tp(10.0)); }
00789
00790
00791 template<typename _Tp>
00792 inline complex<_Tp>
00793 __complex_sin(const complex<_Tp>& __z)
00794 {
00795 const _Tp __x = __z.real();
00796 const _Tp __y = __z.imag();
00797 return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
00798 }
00799
00800 #if _GLIBCXX_USE_C99_COMPLEX
00801 inline __complex__ float
00802 __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
00803
00804 inline __complex__ double
00805 __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
00806
00807 inline __complex__ long double
00808 __complex_sin(const __complex__ long double& __z)
00809 { return __builtin_csinl(__z); }
00810
00811 template<typename _Tp>
00812 inline complex<_Tp>
00813 sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
00814 #else
00815 template<typename _Tp>
00816 inline complex<_Tp>
00817 sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
00818 #endif
00819
00820
00821 template<typename _Tp>
00822 inline complex<_Tp>
00823 __complex_sinh(const complex<_Tp>& __z)
00824 {
00825 const _Tp __x = __z.real();
00826 const _Tp __y = __z.imag();
00827 return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
00828 }
00829
00830 #if _GLIBCXX_USE_C99_COMPLEX
00831 inline __complex__ float
00832 __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
00833
00834 inline __complex__ double
00835 __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
00836
00837 inline __complex__ long double
00838 __complex_sinh(const __complex__ long double& __z)
00839 { return __builtin_csinhl(__z); }
00840
00841 template<typename _Tp>
00842 inline complex<_Tp>
00843 sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
00844 #else
00845 template<typename _Tp>
00846 inline complex<_Tp>
00847 sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
00848 #endif
00849
00850
00851
00852 template<typename _Tp>
00853 complex<_Tp>
00854 __complex_sqrt(const complex<_Tp>& __z)
00855 {
00856 _Tp __x = __z.real();
00857 _Tp __y = __z.imag();
00858
00859 if (__x == _Tp())
00860 {
00861 _Tp __t = sqrt(abs(__y) / 2);
00862 return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
00863 }
00864 else
00865 {
00866 _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
00867 _Tp __u = __t / 2;
00868 return __x > _Tp()
00869 ? complex<_Tp>(__u, __y / __t)
00870 : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
00871 }
00872 }
00873
00874 #if _GLIBCXX_USE_C99_COMPLEX
00875 inline __complex__ float
00876 __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
00877
00878 inline __complex__ double
00879 __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
00880
00881 inline __complex__ long double
00882 __complex_sqrt(const __complex__ long double& __z)
00883 { return __builtin_csqrtl(__z); }
00884
00885 template<typename _Tp>
00886 inline complex<_Tp>
00887 sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
00888 #else
00889 template<typename _Tp>
00890 inline complex<_Tp>
00891 sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
00892 #endif
00893
00894
00895
00896 template<typename _Tp>
00897 inline complex<_Tp>
00898 __complex_tan(const complex<_Tp>& __z)
00899 { return std::sin(__z) / std::cos(__z); }
00900
00901 #if _GLIBCXX_USE_C99_COMPLEX
00902 inline __complex__ float
00903 __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
00904
00905 inline __complex__ double
00906 __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
00907
00908 inline __complex__ long double
00909 __complex_tan(const __complex__ long double& __z)
00910 { return __builtin_ctanl(__z); }
00911
00912 template<typename _Tp>
00913 inline complex<_Tp>
00914 tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
00915 #else
00916 template<typename _Tp>
00917 inline complex<_Tp>
00918 tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
00919 #endif
00920
00921
00922
00923
00924 template<typename _Tp>
00925 inline complex<_Tp>
00926 __complex_tanh(const complex<_Tp>& __z)
00927 { return std::sinh(__z) / std::cosh(__z); }
00928
00929 #if _GLIBCXX_USE_C99_COMPLEX
00930 inline __complex__ float
00931 __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
00932
00933 inline __complex__ double
00934 __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
00935
00936 inline __complex__ long double
00937 __complex_tanh(const __complex__ long double& __z)
00938 { return __builtin_ctanhl(__z); }
00939
00940 template<typename _Tp>
00941 inline complex<_Tp>
00942 tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
00943 #else
00944 template<typename _Tp>
00945 inline complex<_Tp>
00946 tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
00947 #endif
00948
00949
00950
00951
00952
00953 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00954
00955
00956 template<typename _Tp>
00957 inline complex<_Tp>
00958 pow(const complex<_Tp>& __z, int __n)
00959 { return std::__pow_helper(__z, __n); }
00960 #endif
00961
00962 template<typename _Tp>
00963 complex<_Tp>
00964 pow(const complex<_Tp>& __x, const _Tp& __y)
00965 {
00966 #ifndef _GLIBCXX_USE_C99_COMPLEX
00967 if (__x == _Tp())
00968 return _Tp();
00969 #endif
00970 if (__x.imag() == _Tp() && __x.real() > _Tp())
00971 return pow(__x.real(), __y);
00972
00973 complex<_Tp> __t = std::log(__x);
00974 return std::polar(exp(__y * __t.real()), __y * __t.imag());
00975 }
00976
00977 template<typename _Tp>
00978 inline complex<_Tp>
00979 __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
00980 { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
00981
00982 #if _GLIBCXX_USE_C99_COMPLEX
00983 inline __complex__ float
00984 __complex_pow(__complex__ float __x, __complex__ float __y)
00985 { return __builtin_cpowf(__x, __y); }
00986
00987 inline __complex__ double
00988 __complex_pow(__complex__ double __x, __complex__ double __y)
00989 { return __builtin_cpow(__x, __y); }
00990
00991 inline __complex__ long double
00992 __complex_pow(const __complex__ long double& __x,
00993 const __complex__ long double& __y)
00994 { return __builtin_cpowl(__x, __y); }
00995
00996 template<typename _Tp>
00997 inline complex<_Tp>
00998 pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
00999 { return __complex_pow(__x.__rep(), __y.__rep()); }
01000 #else
01001 template<typename _Tp>
01002 inline complex<_Tp>
01003 pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
01004 { return __complex_pow(__x, __y); }
01005 #endif
01006
01007 template<typename _Tp>
01008 inline complex<_Tp>
01009 pow(const _Tp& __x, const complex<_Tp>& __y)
01010 {
01011 return __x > _Tp() ? std::polar(pow(__x, __y.real()),
01012 __y.imag() * log(__x))
01013 : std::pow(complex<_Tp>(__x), __y);
01014 }
01015
01016
01017
01018 template<>
01019 struct complex<float>
01020 {
01021 typedef float value_type;
01022 typedef __complex__ float _ComplexT;
01023
01024 complex(_ComplexT __z) : _M_value(__z) { }
01025
01026 complex(float __r = 0.0f, float __i = 0.0f)
01027 {
01028 __real__ _M_value = __r;
01029 __imag__ _M_value = __i;
01030 }
01031
01032 explicit complex(const complex<double>&);
01033 explicit complex(const complex<long double>&);
01034
01035 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01036
01037
01038 float real() const
01039 { return __real__ _M_value; }
01040
01041 float imag() const
01042 { return __imag__ _M_value; }
01043 #else
01044 float& real()
01045 { return __real__ _M_value; }
01046
01047 const float& real() const
01048 { return __real__ _M_value; }
01049
01050 float& imag()
01051 { return __imag__ _M_value; }
01052
01053 const float& imag() const
01054 { return __imag__ _M_value; }
01055 #endif
01056
01057
01058
01059 void real(float __val)
01060 { __real__ _M_value = __val; }
01061
01062 void imag(float __val)
01063 { __imag__ _M_value = __val; }
01064
01065 complex<float>&
01066 operator=(float __f)
01067 {
01068 __real__ _M_value = __f;
01069 __imag__ _M_value = 0.0f;
01070 return *this;
01071 }
01072
01073 complex<float>&
01074 operator+=(float __f)
01075 {
01076 __real__ _M_value += __f;
01077 return *this;
01078 }
01079
01080 complex<float>&
01081 operator-=(float __f)
01082 {
01083 __real__ _M_value -= __f;
01084 return *this;
01085 }
01086
01087 complex<float>&
01088 operator*=(float __f)
01089 {
01090 _M_value *= __f;
01091 return *this;
01092 }
01093
01094 complex<float>&
01095 operator/=(float __f)
01096 {
01097 _M_value /= __f;
01098 return *this;
01099 }
01100
01101
01102
01103
01104
01105 template<typename _Tp>
01106 complex<float>&
01107 operator=(const complex<_Tp>& __z)
01108 {
01109 __real__ _M_value = __z.real();
01110 __imag__ _M_value = __z.imag();
01111 return *this;
01112 }
01113
01114 template<typename _Tp>
01115 complex<float>&
01116 operator+=(const complex<_Tp>& __z)
01117 {
01118 __real__ _M_value += __z.real();
01119 __imag__ _M_value += __z.imag();
01120 return *this;
01121 }
01122
01123 template<class _Tp>
01124 complex<float>&
01125 operator-=(const complex<_Tp>& __z)
01126 {
01127 __real__ _M_value -= __z.real();
01128 __imag__ _M_value -= __z.imag();
01129 return *this;
01130 }
01131
01132 template<class _Tp>
01133 complex<float>&
01134 operator*=(const complex<_Tp>& __z)
01135 {
01136 _ComplexT __t;
01137 __real__ __t = __z.real();
01138 __imag__ __t = __z.imag();
01139 _M_value *= __t;
01140 return *this;
01141 }
01142
01143 template<class _Tp>
01144 complex<float>&
01145 operator/=(const complex<_Tp>& __z)
01146 {
01147 _ComplexT __t;
01148 __real__ __t = __z.real();
01149 __imag__ __t = __z.imag();
01150 _M_value /= __t;
01151 return *this;
01152 }
01153
01154 const _ComplexT& __rep() const { return _M_value; }
01155
01156 private:
01157 _ComplexT _M_value;
01158 };
01159
01160
01161
01162 template<>
01163 struct complex<double>
01164 {
01165 typedef double value_type;
01166 typedef __complex__ double _ComplexT;
01167
01168 complex(_ComplexT __z) : _M_value(__z) { }
01169
01170 complex(double __r = 0.0, double __i = 0.0)
01171 {
01172 __real__ _M_value = __r;
01173 __imag__ _M_value = __i;
01174 }
01175
01176 complex(const complex<float>& __z)
01177 : _M_value(__z.__rep()) { }
01178
01179 explicit complex(const complex<long double>&);
01180
01181 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01182
01183
01184 double real() const
01185 { return __real__ _M_value; }
01186
01187 double imag() const
01188 { return __imag__ _M_value; }
01189 #else
01190 double& real()
01191 { return __real__ _M_value; }
01192
01193 const double& real() const
01194 { return __real__ _M_value; }
01195
01196 double& imag()
01197 { return __imag__ _M_value; }
01198
01199 const double& imag() const
01200 { return __imag__ _M_value; }
01201 #endif
01202
01203
01204
01205 void real(double __val)
01206 { __real__ _M_value = __val; }
01207
01208 void imag(double __val)
01209 { __imag__ _M_value = __val; }
01210
01211 complex<double>&
01212 operator=(double __d)
01213 {
01214 __real__ _M_value = __d;
01215 __imag__ _M_value = 0.0;
01216 return *this;
01217 }
01218
01219 complex<double>&
01220 operator+=(double __d)
01221 {
01222 __real__ _M_value += __d;
01223 return *this;
01224 }
01225
01226 complex<double>&
01227 operator-=(double __d)
01228 {
01229 __real__ _M_value -= __d;
01230 return *this;
01231 }
01232
01233 complex<double>&
01234 operator*=(double __d)
01235 {
01236 _M_value *= __d;
01237 return *this;
01238 }
01239
01240 complex<double>&
01241 operator/=(double __d)
01242 {
01243 _M_value /= __d;
01244 return *this;
01245 }
01246
01247
01248
01249
01250 template<typename _Tp>
01251 complex<double>&
01252 operator=(const complex<_Tp>& __z)
01253 {
01254 __real__ _M_value = __z.real();
01255 __imag__ _M_value = __z.imag();
01256 return *this;
01257 }
01258
01259 template<typename _Tp>
01260 complex<double>&
01261 operator+=(const complex<_Tp>& __z)
01262 {
01263 __real__ _M_value += __z.real();
01264 __imag__ _M_value += __z.imag();
01265 return *this;
01266 }
01267
01268 template<typename _Tp>
01269 complex<double>&
01270 operator-=(const complex<_Tp>& __z)
01271 {
01272 __real__ _M_value -= __z.real();
01273 __imag__ _M_value -= __z.imag();
01274 return *this;
01275 }
01276
01277 template<typename _Tp>
01278 complex<double>&
01279 operator*=(const complex<_Tp>& __z)
01280 {
01281 _ComplexT __t;
01282 __real__ __t = __z.real();
01283 __imag__ __t = __z.imag();
01284 _M_value *= __t;
01285 return *this;
01286 }
01287
01288 template<typename _Tp>
01289 complex<double>&
01290 operator/=(const complex<_Tp>& __z)
01291 {
01292 _ComplexT __t;
01293 __real__ __t = __z.real();
01294 __imag__ __t = __z.imag();
01295 _M_value /= __t;
01296 return *this;
01297 }
01298
01299 const _ComplexT& __rep() const { return _M_value; }
01300
01301 private:
01302 _ComplexT _M_value;
01303 };
01304
01305
01306
01307 template<>
01308 struct complex<long double>
01309 {
01310 typedef long double value_type;
01311 typedef __complex__ long double _ComplexT;
01312
01313 complex(_ComplexT __z) : _M_value(__z) { }
01314
01315 complex(long double __r = 0.0L, long double __i = 0.0L)
01316 {
01317 __real__ _M_value = __r;
01318 __imag__ _M_value = __i;
01319 }
01320
01321 complex(const complex<float>& __z)
01322 : _M_value(__z.__rep()) { }
01323
01324 complex(const complex<double>& __z)
01325 : _M_value(__z.__rep()) { }
01326
01327 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01328
01329
01330 long double real() const
01331 { return __real__ _M_value; }
01332
01333 long double imag() const
01334 { return __imag__ _M_value; }
01335 #else
01336 long double& real()
01337 { return __real__ _M_value; }
01338
01339 const long double& real() const
01340 { return __real__ _M_value; }
01341
01342 long double& imag()
01343 { return __imag__ _M_value; }
01344
01345 const long double& imag() const
01346 { return __imag__ _M_value; }
01347 #endif
01348
01349
01350
01351 void real(long double __val)
01352 { __real__ _M_value = __val; }
01353
01354 void imag(long double __val)
01355 { __imag__ _M_value = __val; }
01356
01357 complex<long double>&
01358 operator=(long double __r)
01359 {
01360 __real__ _M_value = __r;
01361 __imag__ _M_value = 0.0L;
01362 return *this;
01363 }
01364
01365 complex<long double>&
01366 operator+=(long double __r)
01367 {
01368 __real__ _M_value += __r;
01369 return *this;
01370 }
01371
01372 complex<long double>&
01373 operator-=(long double __r)
01374 {
01375 __real__ _M_value -= __r;
01376 return *this;
01377 }
01378
01379 complex<long double>&
01380 operator*=(long double __r)
01381 {
01382 _M_value *= __r;
01383 return *this;
01384 }
01385
01386 complex<long double>&
01387 operator/=(long double __r)
01388 {
01389 _M_value /= __r;
01390 return *this;
01391 }
01392
01393
01394
01395
01396 template<typename _Tp>
01397 complex<long double>&
01398 operator=(const complex<_Tp>& __z)
01399 {
01400 __real__ _M_value = __z.real();
01401 __imag__ _M_value = __z.imag();
01402 return *this;
01403 }
01404
01405 template<typename _Tp>
01406 complex<long double>&
01407 operator+=(const complex<_Tp>& __z)
01408 {
01409 __real__ _M_value += __z.real();
01410 __imag__ _M_value += __z.imag();
01411 return *this;
01412 }
01413
01414 template<typename _Tp>
01415 complex<long double>&
01416 operator-=(const complex<_Tp>& __z)
01417 {
01418 __real__ _M_value -= __z.real();
01419 __imag__ _M_value -= __z.imag();
01420 return *this;
01421 }
01422
01423 template<typename _Tp>
01424 complex<long double>&
01425 operator*=(const complex<_Tp>& __z)
01426 {
01427 _ComplexT __t;
01428 __real__ __t = __z.real();
01429 __imag__ __t = __z.imag();
01430 _M_value *= __t;
01431 return *this;
01432 }
01433
01434 template<typename _Tp>
01435 complex<long double>&
01436 operator/=(const complex<_Tp>& __z)
01437 {
01438 _ComplexT __t;
01439 __real__ __t = __z.real();
01440 __imag__ __t = __z.imag();
01441 _M_value /= __t;
01442 return *this;
01443 }
01444
01445 const _ComplexT& __rep() const { return _M_value; }
01446
01447 private:
01448 _ComplexT _M_value;
01449 };
01450
01451
01452
01453 inline
01454 complex<float>::complex(const complex<double>& __z)
01455 : _M_value(__z.__rep()) { }
01456
01457 inline
01458 complex<float>::complex(const complex<long double>& __z)
01459 : _M_value(__z.__rep()) { }
01460
01461 inline
01462 complex<double>::complex(const complex<long double>& __z)
01463 : _M_value(__z.__rep()) { }
01464
01465
01466
01467
01468 #if _GLIBCXX_EXTERN_TEMPLATE
01469 extern template istream& operator>>(istream&, complex<float>&);
01470 extern template ostream& operator<<(ostream&, const complex<float>&);
01471 extern template istream& operator>>(istream&, complex<double>&);
01472 extern template ostream& operator<<(ostream&, const complex<double>&);
01473 extern template istream& operator>>(istream&, complex<long double>&);
01474 extern template ostream& operator<<(ostream&, const complex<long double>&);
01475
01476 #ifdef _GLIBCXX_USE_WCHAR_T
01477 extern template wistream& operator>>(wistream&, complex<float>&);
01478 extern template wostream& operator<<(wostream&, const complex<float>&);
01479 extern template wistream& operator>>(wistream&, complex<double>&);
01480 extern template wostream& operator<<(wostream&, const complex<double>&);
01481 extern template wistream& operator>>(wistream&, complex<long double>&);
01482 extern template wostream& operator<<(wostream&, const complex<long double>&);
01483 #endif
01484 #endif
01485
01486
01487
01488 _GLIBCXX_END_NAMESPACE
01489
01490 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
01491
01492
01493 template<typename _Tp, typename _Up>
01494 struct __promote_2<std::complex<_Tp>, _Up>
01495 {
01496 public:
01497 typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
01498 };
01499
01500 template<typename _Tp, typename _Up>
01501 struct __promote_2<_Tp, std::complex<_Up> >
01502 {
01503 public:
01504 typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
01505 };
01506
01507 template<typename _Tp, typename _Up>
01508 struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
01509 {
01510 public:
01511 typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
01512 };
01513
01514 _GLIBCXX_END_NAMESPACE
01515
01516 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01517 # if defined(_GLIBCXX_INCLUDE_AS_TR1)
01518 # error C++0x header cannot be included from TR1 header
01519 # endif
01520 # if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
01521 # include <tr1_impl/complex>
01522 # else
01523 # define _GLIBCXX_INCLUDE_AS_CXX0X
01524 # define _GLIBCXX_BEGIN_NAMESPACE_TR1
01525 # define _GLIBCXX_END_NAMESPACE_TR1
01526 # define _GLIBCXX_TR1
01527 # include <tr1_impl/complex>
01528 # undef _GLIBCXX_TR1
01529 # undef _GLIBCXX_END_NAMESPACE_TR1
01530 # undef _GLIBCXX_BEGIN_NAMESPACE_TR1
01531 # undef _GLIBCXX_INCLUDE_AS_CXX0X
01532 # endif
01533
01534 _GLIBCXX_BEGIN_NAMESPACE(std)
01535
01536
01537
01538 template<typename _Tp> std::complex<_Tp> proj(const std::complex<_Tp>&);
01539
01540 template<typename _Tp>
01541 std::complex<_Tp>
01542 __complex_proj(const std::complex<_Tp>& __z)
01543 {
01544 const _Tp __den = (__z.real() * __z.real()
01545 + __z.imag() * __z.imag() + _Tp(1.0));
01546
01547 return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den,
01548 (_Tp(2.0) * __z.imag()) / __den);
01549 }
01550
01551 #if _GLIBCXX_USE_C99_COMPLEX
01552 inline __complex__ float
01553 __complex_proj(__complex__ float __z)
01554 { return __builtin_cprojf(__z); }
01555
01556 inline __complex__ double
01557 __complex_proj(__complex__ double __z)
01558 { return __builtin_cproj(__z); }
01559
01560 inline __complex__ long double
01561 __complex_proj(const __complex__ long double& __z)
01562 { return __builtin_cprojl(__z); }
01563
01564 template<typename _Tp>
01565 inline std::complex<_Tp>
01566 proj(const std::complex<_Tp>& __z)
01567 { return __complex_proj(__z.__rep()); }
01568 #else
01569 template<typename _Tp>
01570 inline std::complex<_Tp>
01571 proj(const std::complex<_Tp>& __z)
01572 { return __complex_proj(__z); }
01573 #endif
01574
01575 template<typename _Tp>
01576 inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
01577 proj(_Tp __x)
01578 {
01579 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
01580 return std::proj(std::complex<__type>(__x));
01581 }
01582
01583 _GLIBCXX_END_NAMESPACE
01584
01585 #endif
01586
01587 #endif