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