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
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>::_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 inline complex<_Tp>
00569 pow(const complex<_Tp>& __x, const _Tp& __y)
00570 {
00571 return exp(__y * log(__x));
00572 }
00573
00574 template<typename _Tp>
00575 inline complex<_Tp>
00576 pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
00577 {
00578 return exp(__y * log(__x));
00579 }
00580
00581 template<typename _Tp>
00582 inline complex<_Tp>
00583 pow(const _Tp& __x, const complex<_Tp>& __y)
00584 {
00585 return exp(__y * log(__x));
00586 }
00587
00588
00589
00590 template<> class complex<float>
00591 {
00592 public:
00593 typedef float value_type;
00594
00595 complex(float = 0.0f, float = 0.0f);
00596 #ifdef _GLIBCPP_BUGGY_COMPLEX
00597 complex(const complex& __z) : _M_value(__z._M_value) { }
00598 #endif
00599 explicit complex(const complex<double>&);
00600 explicit complex(const complex<long double>&);
00601
00602 float real() const;
00603 float imag() const;
00604
00605 complex<float>& operator=(float);
00606 complex<float>& operator+=(float);
00607 complex<float>& operator-=(float);
00608 complex<float>& operator*=(float);
00609 complex<float>& operator/=(float);
00610
00611
00612
00613
00614 template<typename _Tp>
00615 complex<float>&operator=(const complex<_Tp>&);
00616 template<typename _Tp>
00617 complex<float>& operator+=(const complex<_Tp>&);
00618 template<class _Tp>
00619 complex<float>& operator-=(const complex<_Tp>&);
00620 template<class _Tp>
00621 complex<float>& operator*=(const complex<_Tp>&);
00622 template<class _Tp>
00623 complex<float>&operator/=(const complex<_Tp>&);
00624
00625 private:
00626 typedef __complex__ float _ComplexT;
00627 _ComplexT _M_value;
00628
00629 complex(_ComplexT __z) : _M_value(__z) { }
00630
00631 friend class complex<double>;
00632 friend class complex<long double>;
00633 };
00634
00635 inline float
00636 complex<float>::real() const
00637 { return __real__ _M_value; }
00638
00639 inline float
00640 complex<float>::imag() const
00641 { return __imag__ _M_value; }
00642
00643 inline
00644 complex<float>::complex(float r, float i)
00645 {
00646 __real__ _M_value = r;
00647 __imag__ _M_value = i;
00648 }
00649
00650 inline complex<float>&
00651 complex<float>::operator=(float __f)
00652 {
00653 __real__ _M_value = __f;
00654 __imag__ _M_value = 0.0f;
00655 return *this;
00656 }
00657
00658 inline complex<float>&
00659 complex<float>::operator+=(float __f)
00660 {
00661 __real__ _M_value += __f;
00662 return *this;
00663 }
00664
00665 inline complex<float>&
00666 complex<float>::operator-=(float __f)
00667 {
00668 __real__ _M_value -= __f;
00669 return *this;
00670 }
00671
00672 inline complex<float>&
00673 complex<float>::operator*=(float __f)
00674 {
00675 _M_value *= __f;
00676 return *this;
00677 }
00678
00679 inline complex<float>&
00680 complex<float>::operator/=(float __f)
00681 {
00682 _M_value /= __f;
00683 return *this;
00684 }
00685
00686 template<typename _Tp>
00687 inline complex<float>&
00688 complex<float>::operator=(const complex<_Tp>& __z)
00689 {
00690 __real__ _M_value = __z.real();
00691 __imag__ _M_value = __z.imag();
00692 return *this;
00693 }
00694
00695 template<typename _Tp>
00696 inline complex<float>&
00697 complex<float>::operator+=(const complex<_Tp>& __z)
00698 {
00699 __real__ _M_value += __z.real();
00700 __imag__ _M_value += __z.imag();
00701 return *this;
00702 }
00703
00704 template<typename _Tp>
00705 inline complex<float>&
00706 complex<float>::operator-=(const complex<_Tp>& __z)
00707 {
00708 __real__ _M_value -= __z.real();
00709 __imag__ _M_value -= __z.imag();
00710 return *this;
00711 }
00712
00713 template<typename _Tp>
00714 inline complex<float>&
00715 complex<float>::operator*=(const complex<_Tp>& __z)
00716 {
00717 _ComplexT __t;
00718 __real__ __t = __z.real();
00719 __imag__ __t = __z.imag();
00720 _M_value *= __t;
00721 return *this;
00722 }
00723
00724 template<typename _Tp>
00725 inline complex<float>&
00726 complex<float>::operator/=(const complex<_Tp>& __z)
00727 {
00728 _ComplexT __t;
00729 __real__ __t = __z.real();
00730 __imag__ __t = __z.imag();
00731 _M_value /= __t;
00732 return *this;
00733 }
00734
00735
00736
00737 template<> class complex<double>
00738 {
00739 public:
00740 typedef double value_type;
00741
00742 complex(double =0.0, double =0.0);
00743 #ifdef _GLIBCPP_BUGGY_COMPLEX
00744 complex(const complex& __z) : _M_value(__z._M_value) { }
00745 #endif
00746 complex(const complex<float>&);
00747 explicit complex(const complex<long double>&);
00748
00749 double real() const;
00750 double imag() const;
00751
00752 complex<double>& operator=(double);
00753 complex<double>& operator+=(double);
00754 complex<double>& operator-=(double);
00755 complex<double>& operator*=(double);
00756 complex<double>& operator/=(double);
00757
00758
00759
00760 template<typename _Tp>
00761 complex<double>& operator=(const complex<_Tp>&);
00762 template<typename _Tp>
00763 complex<double>& operator+=(const complex<_Tp>&);
00764 template<typename _Tp>
00765 complex<double>& operator-=(const complex<_Tp>&);
00766 template<typename _Tp>
00767 complex<double>& operator*=(const complex<_Tp>&);
00768 template<typename _Tp>
00769 complex<double>& operator/=(const complex<_Tp>&);
00770
00771 private:
00772 typedef __complex__ double _ComplexT;
00773 _ComplexT _M_value;
00774
00775 complex(_ComplexT __z) : _M_value(__z) { }
00776
00777 friend class complex<float>;
00778 friend class complex<long double>;
00779 };
00780
00781 inline double
00782 complex<double>::real() const
00783 { return __real__ _M_value; }
00784
00785 inline double
00786 complex<double>::imag() const
00787 { return __imag__ _M_value; }
00788
00789 inline
00790 complex<double>::complex(double __r, double __i)
00791 {
00792 __real__ _M_value = __r;
00793 __imag__ _M_value = __i;
00794 }
00795
00796 inline complex<double>&
00797 complex<double>::operator=(double __d)
00798 {
00799 __real__ _M_value = __d;
00800 __imag__ _M_value = 0.0;
00801 return *this;
00802 }
00803
00804 inline complex<double>&
00805 complex<double>::operator+=(double __d)
00806 {
00807 __real__ _M_value += __d;
00808 return *this;
00809 }
00810
00811 inline complex<double>&
00812 complex<double>::operator-=(double __d)
00813 {
00814 __real__ _M_value -= __d;
00815 return *this;
00816 }
00817
00818 inline complex<double>&
00819 complex<double>::operator*=(double __d)
00820 {
00821 _M_value *= __d;
00822 return *this;
00823 }
00824
00825 inline complex<double>&
00826 complex<double>::operator/=(double __d)
00827 {
00828 _M_value /= __d;
00829 return *this;
00830 }
00831
00832 template<typename _Tp>
00833 inline complex<double>&
00834 complex<double>::operator=(const complex<_Tp>& __z)
00835 {
00836 __real__ _M_value = __z.real();
00837 __imag__ _M_value = __z.imag();
00838 return *this;
00839 }
00840
00841 template<typename _Tp>
00842 inline complex<double>&
00843 complex<double>::operator+=(const complex<_Tp>& __z)
00844 {
00845 __real__ _M_value += __z.real();
00846 __imag__ _M_value += __z.imag();
00847 return *this;
00848 }
00849
00850 template<typename _Tp>
00851 inline complex<double>&
00852 complex<double>::operator-=(const complex<_Tp>& __z)
00853 {
00854 __real__ _M_value -= __z.real();
00855 __imag__ _M_value -= __z.imag();
00856 return *this;
00857 }
00858
00859 template<typename _Tp>
00860 inline complex<double>&
00861 complex<double>::operator*=(const complex<_Tp>& __z)
00862 {
00863 _ComplexT __t;
00864 __real__ __t = __z.real();
00865 __imag__ __t = __z.imag();
00866 _M_value *= __t;
00867 return *this;
00868 }
00869
00870 template<typename _Tp>
00871 inline complex<double>&
00872 complex<double>::operator/=(const complex<_Tp>& __z)
00873 {
00874 _ComplexT __t;
00875 __real__ __t = __z.real();
00876 __imag__ __t = __z.imag();
00877 _M_value /= __t;
00878 return *this;
00879 }
00880
00881
00882
00883 template<> class complex<long double>
00884 {
00885 public:
00886 typedef long double value_type;
00887
00888 complex(long double = 0.0L, long double = 0.0L);
00889 #ifdef _GLIBCPP_BUGGY_COMPLEX
00890 complex(const complex& __z) : _M_value(__z._M_value) { }
00891 #endif
00892 complex(const complex<float>&);
00893 complex(const complex<double>&);
00894
00895 long double real() const;
00896 long double imag() const;
00897
00898 complex<long double>& operator= (long double);
00899 complex<long double>& operator+= (long double);
00900 complex<long double>& operator-= (long double);
00901 complex<long double>& operator*= (long double);
00902 complex<long double>& operator/= (long double);
00903
00904
00905
00906 template<typename _Tp>
00907 complex<long double>& operator=(const complex<_Tp>&);
00908 template<typename _Tp>
00909 complex<long double>& operator+=(const complex<_Tp>&);
00910 template<typename _Tp>
00911 complex<long double>& operator-=(const complex<_Tp>&);
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
00917 private:
00918 typedef __complex__ long double _ComplexT;
00919 _ComplexT _M_value;
00920
00921 complex(_ComplexT __z) : _M_value(__z) { }
00922
00923 friend class complex<float>;
00924 friend class complex<double>;
00925 };
00926
00927 inline
00928 complex<long double>::complex(long double __r, long double __i)
00929 {
00930 __real__ _M_value = __r;
00931 __imag__ _M_value = __i;
00932 }
00933
00934 inline long double
00935 complex<long double>::real() const
00936 { return __real__ _M_value; }
00937
00938 inline long double
00939 complex<long double>::imag() const
00940 { return __imag__ _M_value; }
00941
00942 inline complex<long double>&
00943 complex<long double>::operator=(long double __r)
00944 {
00945 __real__ _M_value = __r;
00946 __imag__ _M_value = 0.0L;
00947 return *this;
00948 }
00949
00950 inline complex<long double>&
00951 complex<long double>::operator+=(long double __r)
00952 {
00953 __real__ _M_value += __r;
00954 return *this;
00955 }
00956
00957 inline complex<long double>&
00958 complex<long double>::operator-=(long double __r)
00959 {
00960 __real__ _M_value -= __r;
00961 return *this;
00962 }
00963
00964 inline complex<long double>&
00965 complex<long double>::operator*=(long double __r)
00966 {
00967 _M_value *= __r;
00968 return *this;
00969 }
00970
00971 inline complex<long double>&
00972 complex<long double>::operator/=(long double __r)
00973 {
00974 _M_value /= __r;
00975 return *this;
00976 }
00977
00978 template<typename _Tp>
00979 inline complex<long double>&
00980 complex<long double>::operator=(const complex<_Tp>& __z)
00981 {
00982 __real__ _M_value = __z.real();
00983 __imag__ _M_value = __z.imag();
00984 return *this;
00985 }
00986
00987 template<typename _Tp>
00988 inline complex<long double>&
00989 complex<long double>::operator+=(const complex<_Tp>& __z)
00990 {
00991 __real__ _M_value += __z.real();
00992 __imag__ _M_value += __z.imag();
00993 return *this;
00994 }
00995
00996 template<typename _Tp>
00997 inline complex<long double>&
00998 complex<long double>::operator-=(const complex<_Tp>& __z)
00999 {
01000 __real__ _M_value -= __z.real();
01001 __imag__ _M_value -= __z.imag();
01002 return *this;
01003 }
01004
01005 template<typename _Tp>
01006 inline complex<long double>&
01007 complex<long double>::operator*=(const complex<_Tp>& __z)
01008 {
01009 _ComplexT __t;
01010 __real__ __t = __z.real();
01011 __imag__ __t = __z.imag();
01012 _M_value *= __t;
01013 return *this;
01014 }
01015
01016 template<typename _Tp>
01017 inline complex<long double>&
01018 complex<long double>::operator/=(const complex<_Tp>& __z)
01019 {
01020 _ComplexT __t;
01021 __real__ __t = __z.real();
01022 __imag__ __t = __z.imag();
01023 _M_value /= __t;
01024 return *this;
01025 }
01026
01027
01028
01029
01030
01031 inline
01032 complex<float>::complex(const complex<double>& __z)
01033 : _M_value(_ComplexT(__z._M_value)) { }
01034
01035 inline
01036 complex<float>::complex(const complex<long double>& __z)
01037 : _M_value(_ComplexT(__z._M_value)) { }
01038
01039 inline
01040 complex<double>::complex(const complex<float>& __z)
01041 : _M_value(_ComplexT(__z._M_value)) { }
01042
01043 inline
01044 complex<double>::complex(const complex<long double>& __z)
01045 {
01046 __real__ _M_value = __z.real();
01047 __imag__ _M_value = __z.imag();
01048 }
01049
01050 inline
01051 complex<long double>::complex(const complex<float>& __z)
01052 : _M_value(_ComplexT(__z._M_value)) { }
01053
01054 inline
01055 complex<long double>::complex(const complex<double>& __z)
01056 : _M_value(_ComplexT(__z._M_value)) { }
01057 }
01058
01059 #endif