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
00039
00040
00041
00042
00043 #ifndef _CPP_COMPLEX
00044 #define _CPP_COMPLEX 1
00045
00046 #pragma GCC system_header
00047
00048 #include <bits/c++config.h>
00049 #include <bits/cpp_type_traits.h>
00050 #include <cmath>
00051 #include <sstream>
00052
00053 namespace std
00054 {
00055
00056 template<typename _Tp> class complex;
00057 template<> class complex<float>;
00058 template<> class complex<double>;
00059 template<> class complex<long double>;
00060
00061 template<typename _Tp> _Tp abs(const complex<_Tp>&);
00062 template<typename _Tp> _Tp arg(const complex<_Tp>&);
00063 template<typename _Tp> _Tp norm(const complex<_Tp>&);
00064
00065 template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
00066 template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
00067
00068
00069 template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
00070 template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
00071 template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
00072 template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
00073 template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
00074 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
00075 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
00076 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
00077 const complex<_Tp>&);
00078 template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
00079 template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
00080 template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
00081 template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
00082 template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
00083 template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
00084
00085
00086
00087 template<typename _Tp>
00088 class complex
00089 {
00090 public:
00091 typedef _Tp value_type;
00092
00093 complex(const _Tp& = _Tp(), const _Tp & = _Tp());
00094
00095
00096
00097 template<typename _Up>
00098 complex(const complex<_Up>&);
00099
00100 _Tp real() const;
00101 _Tp imag() const;
00102
00103 complex<_Tp>& operator=(const _Tp&);
00104 complex<_Tp>& operator+=(const _Tp&);
00105 complex<_Tp>& operator-=(const _Tp&);
00106 complex<_Tp>& operator*=(const _Tp&);
00107 complex<_Tp>& operator/=(const _Tp&);
00108
00109
00110
00111
00112 template<typename _Up>
00113 complex<_Tp>& operator=(const complex<_Up>&);
00114 template<typename _Up>
00115 complex<_Tp>& operator+=(const complex<_Up>&);
00116 template<typename _Up>
00117 complex<_Tp>& operator-=(const complex<_Up>&);
00118 template<typename _Up>
00119 complex<_Tp>& operator*=(const complex<_Up>&);
00120 template<typename _Up>
00121 complex<_Tp>& operator/=(const complex<_Up>&);
00122
00123 private:
00124 _Tp _M_real, _M_imag;
00125 };
00126
00127 template<typename _Tp>
00128 inline _Tp
00129 complex<_Tp>::real() const { return _M_real; }
00130
00131 template<typename _Tp>
00132 inline _Tp
00133 complex<_Tp>::imag() const { return _M_imag; }
00134
00135 template<typename _Tp>
00136 inline
00137 complex<_Tp>::complex(const _Tp& __r, const _Tp& __i)
00138 : _M_real(__r), _M_imag(__i) { }
00139
00140 template<typename _Tp>
00141 template<typename _Up>
00142 inline
00143 complex<_Tp>::complex(const complex<_Up>& __z)
00144 : _M_real(__z.real()), _M_imag(__z.imag()) { }
00145
00146 template<typename _Tp>
00147 complex<_Tp>&
00148 complex<_Tp>::operator=(const _Tp& __t)
00149 {
00150 _M_real = __t;
00151 _M_imag = _Tp();
00152 return *this;
00153 }
00154
00155
00156 template<typename _Tp>
00157 inline complex<_Tp>&
00158 complex<_Tp>::operator+=(const _Tp& __t)
00159 {
00160 _M_real += __t;
00161 return *this;
00162 }
00163
00164
00165 template<typename _Tp>
00166 inline complex<_Tp>&
00167 complex<_Tp>::operator-=(const _Tp& __t)
00168 {
00169 _M_real -= __t;
00170 return *this;
00171 }
00172
00173
00174 template<typename _Tp>
00175 complex<_Tp>&
00176 complex<_Tp>::operator*=(const _Tp& __t)
00177 {
00178 _M_real *= __t;
00179 _M_imag *= __t;
00180 return *this;
00181 }
00182
00183
00184 template<typename _Tp>
00185 complex<_Tp>&
00186 complex<_Tp>::operator/=(const _Tp& __t)
00187 {
00188 _M_real /= __t;
00189 _M_imag /= __t;
00190 return *this;
00191 }
00192
00193 template<typename _Tp>
00194 template<typename _Up>
00195 complex<_Tp>&
00196 complex<_Tp>::operator=(const complex<_Up>& __z)
00197 {
00198 _M_real = __z.real();
00199 _M_imag = __z.imag();
00200 return *this;
00201 }
00202
00203
00204 template<typename _Tp>
00205 template<typename _Up>
00206 complex<_Tp>&
00207 complex<_Tp>::operator+=(const complex<_Up>& __z)
00208 {
00209 _M_real += __z.real();
00210 _M_imag += __z.imag();
00211 return *this;
00212 }
00213
00214
00215 template<typename _Tp>
00216 template<typename _Up>
00217 complex<_Tp>&
00218 complex<_Tp>::operator-=(const complex<_Up>& __z)
00219 {
00220 _M_real -= __z.real();
00221 _M_imag -= __z.imag();
00222 return *this;
00223 }
00224
00225
00226
00227 template<typename _Tp>
00228 template<typename _Up>
00229 complex<_Tp>&
00230 complex<_Tp>::operator*=(const complex<_Up>& __z)
00231 {
00232 const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
00233 _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
00234 _M_real = __r;
00235 return *this;
00236 }
00237
00238
00239
00240 template<typename _Tp>
00241 template<typename _Up>
00242 complex<_Tp>&
00243 complex<_Tp>::operator/=(const complex<_Up>& __z)
00244 {
00245 const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
00246 const _Tp __n = norm(__z);
00247 _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
00248 _M_real = __r / __n;
00249 return *this;
00250 }
00251
00252
00253 template<typename _Tp>
00254 inline complex<_Tp>
00255 operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
00256 { return complex<_Tp> (__x) += __y; }
00257
00258 template<typename _Tp>
00259 inline complex<_Tp>
00260 operator+(const complex<_Tp>& __x, const _Tp& __y)
00261 { return complex<_Tp> (__x) += __y; }
00262
00263 template<typename _Tp>
00264 inline complex<_Tp>
00265 operator+(const _Tp& __x, const complex<_Tp>& __y)
00266 { return complex<_Tp> (__y) += __x; }
00267
00268 template<typename _Tp>
00269 inline complex<_Tp>
00270 operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
00271 { return complex<_Tp> (__x) -= __y; }
00272
00273 template<typename _Tp>
00274 inline complex<_Tp>
00275 operator-(const complex<_Tp>& __x, const _Tp& __y)
00276 { return complex<_Tp> (__x) -= __y; }
00277
00278 template<typename _Tp>
00279 inline complex<_Tp>
00280 operator-(const _Tp& __x, const complex<_Tp>& __y)
00281 { return complex<_Tp> (__x) -= __y; }
00282
00283 template<typename _Tp>
00284 inline complex<_Tp>
00285 operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
00286 { return complex<_Tp> (__x) *= __y; }
00287
00288 template<typename _Tp>
00289 inline complex<_Tp>
00290 operator*(const complex<_Tp>& __x, const _Tp& __y)
00291 { return complex<_Tp> (__x) *= __y; }
00292
00293 template<typename _Tp>
00294 inline complex<_Tp>
00295 operator*(const _Tp& __x, const complex<_Tp>& __y)
00296 { return complex<_Tp> (__y) *= __x; }
00297
00298 template<typename _Tp>
00299 inline complex<_Tp>
00300 operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
00301 { return complex<_Tp> (__x) /= __y; }
00302
00303 template<typename _Tp>
00304 inline complex<_Tp>
00305 operator/(const complex<_Tp>& __x, const _Tp& __y)
00306 { return complex<_Tp> (__x) /= __y; }
00307
00308 template<typename _Tp>
00309 inline complex<_Tp>
00310 operator/(const _Tp& __x, const complex<_Tp>& __y)
00311 { return complex<_Tp> (__x) /= __y; }
00312
00313 template<typename _Tp>
00314 inline complex<_Tp>
00315 operator+(const complex<_Tp>& __x)
00316 { return __x; }
00317
00318 template<typename _Tp>
00319 inline complex<_Tp>
00320 operator-(const complex<_Tp>& __x)
00321 { return complex<_Tp>(-__x.real(), -__x.imag()); }
00322
00323 template<typename _Tp>
00324 inline bool
00325 operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
00326 { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
00327
00328 template<typename _Tp>
00329 inline bool
00330 operator==(const complex<_Tp>& __x, const _Tp& __y)
00331 { return __x.real() == __y && __x.imag() == _Tp(); }
00332
00333 template<typename _Tp>
00334 inline bool
00335 operator==(const _Tp& __x, const complex<_Tp>& __y)
00336 { return __x == __y.real() && _Tp() == __y.imag(); }
00337
00338 template<typename _Tp>
00339 inline bool
00340 operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
00341 { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
00342
00343 template<typename _Tp>
00344 inline bool
00345 operator!=(const complex<_Tp>& __x, const _Tp& __y)
00346 { return __x.real() != __y || __x.imag() != _Tp(); }
00347
00348 template<typename _Tp>
00349 inline bool
00350 operator!=(const _Tp& __x, const complex<_Tp>& __y)
00351 { return __x != __y.real() || _Tp() != __y.imag(); }
00352
00353 template<typename _Tp, typename _CharT, class _Traits>
00354 basic_istream<_CharT, _Traits>&
00355 operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
00356 {
00357 _Tp __re_x, __im_x;
00358 _CharT __ch;
00359 __is >> __ch;
00360 if (__ch == '(')
00361 {
00362 __is >> __re_x >> __ch;
00363 if (__ch == ',')
00364 {
00365 __is >> __im_x >> __ch;
00366 if (__ch == ')')
00367 __x = complex<_Tp>(__re_x, __im_x);
00368 else
00369 __is.setstate(ios_base::failbit);
00370 }
00371 else if (__ch == ')')
00372 __x = complex<_Tp>(__re_x, _Tp(0));
00373 else
00374 __is.setstate(ios_base::failbit);
00375 }
00376 else
00377 {
00378 __is.putback(__ch);
00379 __is >> __re_x;
00380 __x = complex<_Tp>(__re_x, _Tp(0));
00381 }
00382 return __is;
00383 }
00384
00385 template<typename _Tp, typename _CharT, class _Traits>
00386 basic_ostream<_CharT, _Traits>&
00387 operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
00388 {
00389 basic_ostringstream<_CharT, _Traits> __s;
00390 __s.flags(__os.flags());
00391 __s.imbue(__os.getloc());
00392 __s.precision(__os.precision());
00393 __s << '(' << __x.real() << ',' << __x.imag() << ')';
00394 return __os << __s.str();
00395 }
00396
00397
00398 template<typename _Tp>
00399 inline _Tp
00400 real(const complex<_Tp>& __z)
00401 { return __z.real(); }
00402
00403 template<typename _Tp>
00404 inline _Tp
00405 imag(const complex<_Tp>& __z)
00406 { return __z.imag(); }
00407
00408 template<typename _Tp>
00409 inline _Tp
00410 abs(const complex<_Tp>& __z)
00411 {
00412 _Tp __x = __z.real();
00413 _Tp __y = __z.imag();
00414 const _Tp __s = max(abs(__x), abs(__y));
00415 if (__s == _Tp())
00416 return __s;
00417 __x /= __s;
00418 __y /= __s;
00419 return __s * sqrt(__x * __x + __y * __y);
00420 }
00421
00422 template<typename _Tp>
00423 inline _Tp
00424 arg(const complex<_Tp>& __z)
00425 { return atan2(__z.imag(), __z.real()); }
00426
00427
00428
00429
00430
00431
00432 template<bool>
00433 struct _Norm_helper
00434 {
00435 template<typename _Tp>
00436 static inline _Tp _S_do_it(const complex<_Tp>& __z)
00437 {
00438 const _Tp __x = __z.real();
00439 const _Tp __y = __z.imag();
00440 return __x * __x + __y * __y;
00441 }
00442 };
00443
00444 template<>
00445 struct _Norm_helper<true>
00446 {
00447 template<typename _Tp>
00448 static inline _Tp _S_do_it(const complex<_Tp>& __z)
00449 {
00450 _Tp __res = abs(__z);
00451 return __res * __res;
00452 }
00453 };
00454
00455 template<typename _Tp>
00456 inline _Tp
00457 norm(const complex<_Tp>& __z)
00458 {
00459 return _Norm_helper<__is_floating<_Tp>::_M_type && !_GLIBCPP_FAST_MATH>::_S_do_it(__z);
00460 }
00461
00462 template<typename _Tp>
00463 inline complex<_Tp>
00464 polar(const _Tp& __rho, const _Tp& __theta)
00465 { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
00466
00467 template<typename _Tp>
00468 inline complex<_Tp>
00469 conj(const complex<_Tp>& __z)
00470 { return complex<_Tp>(__z.real(), -__z.imag()); }
00471
00472
00473 template<typename _Tp>
00474 inline complex<_Tp>
00475 cos(const complex<_Tp>& __z)
00476 {
00477 const _Tp __x = __z.real();
00478 const _Tp __y = __z.imag();
00479 return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
00480 }
00481
00482 template<typename _Tp>
00483 inline complex<_Tp>
00484 cosh(const complex<_Tp>& __z)
00485 {
00486 const _Tp __x = __z.real();
00487 const _Tp __y = __z.imag();
00488 return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
00489 }
00490
00491 template<typename _Tp>
00492 inline complex<_Tp>
00493 exp(const complex<_Tp>& __z)
00494 { return polar(exp(__z.real()), __z.imag()); }
00495
00496 template<typename _Tp>
00497 inline complex<_Tp>
00498 log(const complex<_Tp>& __z)
00499 { return complex<_Tp>(log(abs(__z)), arg(__z)); }
00500
00501 template<typename _Tp>
00502 inline complex<_Tp>
00503 log10(const complex<_Tp>& __z)
00504 { return log(__z) / log(_Tp(10.0)); }
00505
00506 template<typename _Tp>
00507 inline complex<_Tp>
00508 sin(const complex<_Tp>& __z)
00509 {
00510 const _Tp __x = __z.real();
00511 const _Tp __y = __z.imag();
00512 return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
00513 }
00514
00515 template<typename _Tp>
00516 inline complex<_Tp>
00517 sinh(const complex<_Tp>& __z)
00518 {
00519 const _Tp __x = __z.real();
00520 const _Tp __y = __z.imag();
00521 return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
00522 }
00523
00524 template<typename _Tp>
00525 complex<_Tp>
00526 sqrt(const complex<_Tp>& __z)
00527 {
00528 _Tp __x = __z.real();
00529 _Tp __y = __z.imag();
00530
00531 if (__x == _Tp())
00532 {
00533 _Tp __t = sqrt(abs(__y) / 2);
00534 return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
00535 }
00536 else
00537 {
00538 _Tp __t = sqrt(2 * (abs(__z) + abs(__x)));
00539 _Tp __u = __t / 2;
00540 return __x > _Tp()
00541 ? complex<_Tp>(__u, __y / __t)
00542 : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
00543 }
00544 }
00545
00546 template<typename _Tp>
00547 inline complex<_Tp>
00548 tan(const complex<_Tp>& __z)
00549 {
00550 return sin(__z) / cos(__z);
00551 }
00552
00553 template<typename _Tp>
00554 inline complex<_Tp>
00555 tanh(const complex<_Tp>& __z)
00556 {
00557 return sinh(__z) / cosh(__z);
00558 }
00559
00560 template<typename _Tp>
00561 inline complex<_Tp>
00562 pow(const complex<_Tp>& __z, int __n)
00563 {
00564 return __pow_helper(__z, __n);
00565 }
00566
00567 template<typename _Tp>
00568 complex<_Tp>
00569 pow(const complex<_Tp>& __x, const _Tp& __y)
00570 {
00571 if (__x.imag() == _Tp())
00572 return pow(__x.real(), __y);
00573
00574 complex<_Tp> __t = log(__x);
00575 return polar(exp(__y * __t.real()), __y * __t.imag());
00576 }
00577
00578 template<typename _Tp>
00579 inline complex<_Tp>
00580 pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
00581 {
00582 return __x == _Tp() ? _Tp() : exp(__y * log(__x));
00583 }
00584
00585 template<typename _Tp>
00586 inline complex<_Tp>
00587 pow(const _Tp& __x, const complex<_Tp>& __y)
00588 {
00589 return __x == _Tp()
00590 ? _Tp()
00591 : polar(pow(__x, __y.real()), __y.imag() * log(__x));
00592 }
00593
00594
00595
00596 template<> class complex<float>
00597 {
00598 public:
00599 typedef float value_type;
00600
00601 complex(float = 0.0f, float = 0.0f);
00602 #ifdef _GLIBCPP_BUGGY_COMPLEX
00603 complex(const complex& __z) : _M_value(__z._M_value) { }
00604 #endif
00605 explicit complex(const complex<double>&);
00606 explicit complex(const complex<long double>&);
00607
00608 float real() const;
00609 float imag() const;
00610
00611 complex<float>& operator=(float);
00612 complex<float>& operator+=(float);
00613 complex<float>& operator-=(float);
00614 complex<float>& operator*=(float);
00615 complex<float>& operator/=(float);
00616
00617
00618
00619
00620 template<typename _Tp>
00621 complex<float>&operator=(const complex<_Tp>&);
00622 template<typename _Tp>
00623 complex<float>& operator+=(const complex<_Tp>&);
00624 template<class _Tp>
00625 complex<float>& operator-=(const complex<_Tp>&);
00626 template<class _Tp>
00627 complex<float>& operator*=(const complex<_Tp>&);
00628 template<class _Tp>
00629 complex<float>&operator/=(const complex<_Tp>&);
00630
00631 private:
00632 typedef __complex__ float _ComplexT;
00633 _ComplexT _M_value;
00634
00635 complex(_ComplexT __z) : _M_value(__z) { }
00636
00637 friend class complex<double>;
00638 friend class complex<long double>;
00639 };
00640
00641 inline float
00642 complex<float>::real() const
00643 { return __real__ _M_value; }
00644
00645 inline float
00646 complex<float>::imag() const
00647 { return __imag__ _M_value; }
00648
00649 inline
00650 complex<float>::complex(float r, float i)
00651 {
00652 __real__ _M_value = r;
00653 __imag__ _M_value = i;
00654 }
00655
00656 inline complex<float>&
00657 complex<float>::operator=(float __f)
00658 {
00659 __real__ _M_value = __f;
00660 __imag__ _M_value = 0.0f;
00661 return *this;
00662 }
00663
00664 inline complex<float>&
00665 complex<float>::operator+=(float __f)
00666 {
00667 __real__ _M_value += __f;
00668 return *this;
00669 }
00670
00671 inline complex<float>&
00672 complex<float>::operator-=(float __f)
00673 {
00674 __real__ _M_value -= __f;
00675 return *this;
00676 }
00677
00678 inline complex<float>&
00679 complex<float>::operator*=(float __f)
00680 {
00681 _M_value *= __f;
00682 return *this;
00683 }
00684
00685 inline complex<float>&
00686 complex<float>::operator/=(float __f)
00687 {
00688 _M_value /= __f;
00689 return *this;
00690 }
00691
00692 template<typename _Tp>
00693 inline complex<float>&
00694 complex<float>::operator=(const complex<_Tp>& __z)
00695 {
00696 __real__ _M_value = __z.real();
00697 __imag__ _M_value = __z.imag();
00698 return *this;
00699 }
00700
00701 template<typename _Tp>
00702 inline complex<float>&
00703 complex<float>::operator+=(const complex<_Tp>& __z)
00704 {
00705 __real__ _M_value += __z.real();
00706 __imag__ _M_value += __z.imag();
00707 return *this;
00708 }
00709
00710 template<typename _Tp>
00711 inline complex<float>&
00712 complex<float>::operator-=(const complex<_Tp>& __z)
00713 {
00714 __real__ _M_value -= __z.real();
00715 __imag__ _M_value -= __z.imag();
00716 return *this;
00717 }
00718
00719 template<typename _Tp>
00720 inline complex<float>&
00721 complex<float>::operator*=(const complex<_Tp>& __z)
00722 {
00723 _ComplexT __t;
00724 __real__ __t = __z.real();
00725 __imag__ __t = __z.imag();
00726 _M_value *= __t;
00727 return *this;
00728 }
00729
00730 template<typename _Tp>
00731 inline complex<float>&
00732 complex<float>::operator/=(const complex<_Tp>& __z)
00733 {
00734 _ComplexT __t;
00735 __real__ __t = __z.real();
00736 __imag__ __t = __z.imag();
00737 _M_value /= __t;
00738 return *this;
00739 }
00740
00741
00742
00743 template<> class complex<double>
00744 {
00745 public:
00746 typedef double value_type;
00747
00748 complex(double =0.0, double =0.0);
00749 #ifdef _GLIBCPP_BUGGY_COMPLEX
00750 complex(const complex& __z) : _M_value(__z._M_value) { }
00751 #endif
00752 complex(const complex<float>&);
00753 explicit complex(const complex<long double>&);
00754
00755 double real() const;
00756 double imag() const;
00757
00758 complex<double>& operator=(double);
00759 complex<double>& operator+=(double);
00760 complex<double>& operator-=(double);
00761 complex<double>& operator*=(double);
00762 complex<double>& operator/=(double);
00763
00764
00765
00766 template<typename _Tp>
00767 complex<double>& operator=(const complex<_Tp>&);
00768 template<typename _Tp>
00769 complex<double>& operator+=(const complex<_Tp>&);
00770 template<typename _Tp>
00771 complex<double>& operator-=(const complex<_Tp>&);
00772 template<typename _Tp>
00773 complex<double>& operator*=(const complex<_Tp>&);
00774 template<typename _Tp>
00775 complex<double>& operator/=(const complex<_Tp>&);
00776
00777 private:
00778 typedef __complex__ double _ComplexT;
00779 _ComplexT _M_value;
00780
00781 complex(_ComplexT __z) : _M_value(__z) { }
00782
00783 friend class complex<float>;
00784 friend class complex<long double>;
00785 };
00786
00787 inline double
00788 complex<double>::real() const
00789 { return __real__ _M_value; }
00790
00791 inline double
00792 complex<double>::imag() const
00793 { return __imag__ _M_value; }
00794
00795 inline
00796 complex<double>::complex(double __r, double __i)
00797 {
00798 __real__ _M_value = __r;
00799 __imag__ _M_value = __i;
00800 }
00801
00802 inline complex<double>&
00803 complex<double>::operator=(double __d)
00804 {
00805 __real__ _M_value = __d;
00806 __imag__ _M_value = 0.0;
00807 return *this;
00808 }
00809
00810 inline complex<double>&
00811 complex<double>::operator+=(double __d)
00812 {
00813 __real__ _M_value += __d;
00814 return *this;
00815 }
00816
00817 inline complex<double>&
00818 complex<double>::operator-=(double __d)
00819 {
00820 __real__ _M_value -= __d;
00821 return *this;
00822 }
00823
00824 inline complex<double>&
00825 complex<double>::operator*=(double __d)
00826 {
00827 _M_value *= __d;
00828 return *this;
00829 }
00830
00831 inline complex<double>&
00832 complex<double>::operator/=(double __d)
00833 {
00834 _M_value /= __d;
00835 return *this;
00836 }
00837
00838 template<typename _Tp>
00839 inline complex<double>&
00840 complex<double>::operator=(const complex<_Tp>& __z)
00841 {
00842 __real__ _M_value = __z.real();
00843 __imag__ _M_value = __z.imag();
00844 return *this;
00845 }
00846
00847 template<typename _Tp>
00848 inline complex<double>&
00849 complex<double>::operator+=(const complex<_Tp>& __z)
00850 {
00851 __real__ _M_value += __z.real();
00852 __imag__ _M_value += __z.imag();
00853 return *this;
00854 }
00855
00856 template<typename _Tp>
00857 inline complex<double>&
00858 complex<double>::operator-=(const complex<_Tp>& __z)
00859 {
00860 __real__ _M_value -= __z.real();
00861 __imag__ _M_value -= __z.imag();
00862 return *this;
00863 }
00864
00865 template<typename _Tp>
00866 inline complex<double>&
00867 complex<double>::operator*=(const complex<_Tp>& __z)
00868 {
00869 _ComplexT __t;
00870 __real__ __t = __z.real();
00871 __imag__ __t = __z.imag();
00872 _M_value *= __t;
00873 return *this;
00874 }
00875
00876 template<typename _Tp>
00877 inline complex<double>&
00878 complex<double>::operator/=(const complex<_Tp>& __z)
00879 {
00880 _ComplexT __t;
00881 __real__ __t = __z.real();
00882 __imag__ __t = __z.imag();
00883 _M_value /= __t;
00884 return *this;
00885 }
00886
00887
00888
00889 template<> class complex<long double>
00890 {
00891 public:
00892 typedef long double value_type;
00893
00894 complex(long double = 0.0L, long double = 0.0L);
00895 #ifdef _GLIBCPP_BUGGY_COMPLEX
00896 complex(const complex& __z) : _M_value(__z._M_value) { }
00897 #endif
00898 complex(const complex<float>&);
00899 complex(const complex<double>&);
00900
00901 long double real() const;
00902 long double imag() const;
00903
00904 complex<long double>& operator= (long double);
00905 complex<long double>& operator+= (long double);
00906 complex<long double>& operator-= (long double);
00907 complex<long double>& operator*= (long double);
00908 complex<long double>& operator/= (long double);
00909
00910
00911
00912 template<typename _Tp>
00913 complex<long double>& operator=(const complex<_Tp>&);
00914 template<typename _Tp>
00915 complex<long double>& operator+=(const complex<_Tp>&);
00916 template<typename _Tp>
00917 complex<long double>& operator-=(const complex<_Tp>&);
00918 template<typename _Tp>
00919 complex<long double>& operator*=(const complex<_Tp>&);
00920 template<typename _Tp>
00921 complex<long double>& operator/=(const complex<_Tp>&);
00922
00923 private:
00924 typedef __complex__ long double _ComplexT;
00925 _ComplexT _M_value;
00926
00927 complex(_ComplexT __z) : _M_value(__z) { }
00928
00929 friend class complex<float>;
00930 friend class complex<double>;
00931 };
00932
00933 inline
00934 complex<long double>::complex(long double __r, long double __i)
00935 {
00936 __real__ _M_value = __r;
00937 __imag__ _M_value = __i;
00938 }
00939
00940 inline long double
00941 complex<long double>::real() const
00942 { return __real__ _M_value; }
00943
00944 inline long double
00945 complex<long double>::imag() const
00946 { return __imag__ _M_value; }
00947
00948 inline complex<long double>&
00949 complex<long double>::operator=(long double __r)
00950 {
00951 __real__ _M_value = __r;
00952 __imag__ _M_value = 0.0L;
00953 return *this;
00954 }
00955
00956 inline complex<long double>&
00957 complex<long double>::operator+=(long double __r)
00958 {
00959 __real__ _M_value += __r;
00960 return *this;
00961 }
00962
00963 inline complex<long double>&
00964 complex<long double>::operator-=(long double __r)
00965 {
00966 __real__ _M_value -= __r;
00967 return *this;
00968 }
00969
00970 inline complex<long double>&
00971 complex<long double>::operator*=(long double __r)
00972 {
00973 _M_value *= __r;
00974 return *this;
00975 }
00976
00977 inline complex<long double>&
00978 complex<long double>::operator/=(long double __r)
00979 {
00980 _M_value /= __r;
00981 return *this;
00982 }
00983
00984 template<typename _Tp>
00985 inline complex<long double>&
00986 complex<long double>::operator=(const complex<_Tp>& __z)
00987 {
00988 __real__ _M_value = __z.real();
00989 __imag__ _M_value = __z.imag();
00990 return *this;
00991 }
00992
00993 template<typename _Tp>
00994 inline complex<long double>&
00995 complex<long double>::operator+=(const complex<_Tp>& __z)
00996 {
00997 __real__ _M_value += __z.real();
00998 __imag__ _M_value += __z.imag();
00999 return *this;
01000 }
01001
01002 template<typename _Tp>
01003 inline complex<long double>&
01004 complex<long double>::operator-=(const complex<_Tp>& __z)
01005 {
01006 __real__ _M_value -= __z.real();
01007 __imag__ _M_value -= __z.imag();
01008 return *this;
01009 }
01010
01011 template<typename _Tp>
01012 inline complex<long double>&
01013 complex<long double>::operator*=(const complex<_Tp>& __z)
01014 {
01015 _ComplexT __t;
01016 __real__ __t = __z.real();
01017 __imag__ __t = __z.imag();
01018 _M_value *= __t;
01019 return *this;
01020 }
01021
01022 template<typename _Tp>
01023 inline complex<long double>&
01024 complex<long double>::operator/=(const complex<_Tp>& __z)
01025 {
01026 _ComplexT __t;
01027 __real__ __t = __z.real();
01028 __imag__ __t = __z.imag();
01029 _M_value /= __t;
01030 return *this;
01031 }
01032
01033
01034
01035
01036
01037 inline
01038 complex<float>::complex(const complex<double>& __z)
01039 : _M_value(_ComplexT(__z._M_value)) { }
01040
01041 inline
01042 complex<float>::complex(const complex<long double>& __z)
01043 : _M_value(_ComplexT(__z._M_value)) { }
01044
01045 inline
01046 complex<double>::complex(const complex<float>& __z)
01047 : _M_value(_ComplexT(__z._M_value)) { }
01048
01049 inline
01050 complex<double>::complex(const complex<long double>& __z)
01051 {
01052 __real__ _M_value = __z.real();
01053 __imag__ _M_value = __z.imag();
01054 }
01055
01056 inline
01057 complex<long double>::complex(const complex<float>& __z)
01058 : _M_value(_ComplexT(__z._M_value)) { }
01059
01060 inline
01061 complex<long double>::complex(const complex<double>& __z)
01062 : _M_value(_ComplexT(__z._M_value)) { }
01063 }
01064
01065 #endif