williamr@2: /*
williamr@2:  * Copyright (c) 1999
williamr@2:  * Silicon Graphics Computer Systems, Inc.
williamr@2:  *
williamr@4:  * Copyright (c) 1999
williamr@2:  * Boris Fomitchev
williamr@2:  *
williamr@2:  * This material is provided "as is", with absolutely no warranty expressed
williamr@2:  * or implied. Any use is at your own risk.
williamr@2:  *
williamr@4:  * Permission to use or copy this software for any purpose is hereby granted
williamr@2:  * without fee, provided the above notices are retained on all copies.
williamr@2:  * Permission to modify the code and to distribute modified code is granted,
williamr@2:  * provided the above notices are retained, and a notice that the code was
williamr@2:  * modified is included with the above copyright notice.
williamr@2:  *
williamr@4:  */
williamr@4: #ifndef _STLP_INTERNAL_COMPLEX
williamr@4: #define _STLP_INTERNAL_COMPLEX
williamr@2: 
williamr@4: // This header declares the template class complex, as described in
williamr@2: // in the draft C++ standard.  Single-precision complex numbers
williamr@2: // are complex<float>, double-precision are complex<double>, and
williamr@2: // quad precision are complex<long double>.
williamr@2: 
williamr@2: // Note that the template class complex is declared within namespace
williamr@4: // std, as called for by the draft C++ standard.
williamr@2: 
williamr@4: #ifndef _STLP_INTERNAL_CMATH
williamr@4: #  include <stl/_cmath.h>
williamr@4: #endif
williamr@2: 
williamr@2: _STLP_BEGIN_NAMESPACE
williamr@2: 
williamr@4: #if !defined (_STLP_NO_COMPLEX_SPECIALIZATIONS)    //*TY 02/25/2000 - added for MPW compiler workaround
williamr@2: 
williamr@2: template <class _Tp> struct complex;
williamr@2: 
williamr@4: _STLP_TEMPLATE_NULL struct complex<float>;
williamr@4: _STLP_TEMPLATE_NULL struct complex<double>;
williamr@4: #  if !defined (_STLP_NO_LONG_DOUBLE)
williamr@4: _STLP_TEMPLATE_NULL struct complex<long double>;
williamr@4: #  endif
williamr@4: #endif /* _STLP_NO_COMPLEX_SPECIALIZATIONS */
williamr@2: 
williamr@2: template <class _Tp>
williamr@2: struct complex {
williamr@2:   typedef _Tp value_type;
williamr@2:   typedef complex<_Tp> _Self;
williamr@2: 
williamr@2:   // Constructors, destructor, assignment operator.
williamr@2:   complex() : _M_re(0), _M_im(0) {}
williamr@2:   complex(const value_type& __x)
williamr@2:     : _M_re(__x), _M_im(0) {}
williamr@2:   complex(const value_type& __x, const value_type& __y)
williamr@2:     : _M_re(__x), _M_im(__y) {}
williamr@2:   complex(const _Self& __z)
williamr@2:     : _M_re(__z._M_re), _M_im(__z._M_im) {}
williamr@2: 
williamr@2:   _Self& operator=(const _Self& __z) {
williamr@2:     _M_re = __z._M_re;
williamr@2:     _M_im = __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@4: #if defined (_STLP_MEMBER_TEMPLATES) && (defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) || defined(_STLP_NO_COMPLEX_SPECIALIZATIONS))
williamr@2:   template <class _Tp2>
williamr@2:   explicit complex(const complex<_Tp2>& __z)
williamr@2:     : _M_re(__z._M_re), _M_im(__z._M_im) {}
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   _Self& operator=(const complex<_Tp2>& __z) {
williamr@2:     _M_re = __z._M_re;
williamr@2:     _M_im = __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: #endif /* _STLP_MEMBER_TEMPLATES */
williamr@2: 
williamr@2:   // Element access.
williamr@2:   value_type real() const { return _M_re; }
williamr@2:   value_type imag() const { return _M_im; }
williamr@2: 
williamr@2:   // Arithmetic op= operations involving one real argument.
williamr@2: 
williamr@2:   _Self& operator= (const value_type& __x) {
williamr@2:     _M_re = __x;
williamr@2:     _M_im = 0;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator+= (const value_type& __x) {
williamr@2:     _M_re += __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator-= (const value_type& __x) {
williamr@2:     _M_re -= __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator*= (const value_type& __x) {
williamr@2:     _M_re *= __x;
williamr@2:     _M_im *= __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator/= (const value_type& __x) {
williamr@2:     _M_re /= __x;
williamr@2:     _M_im /= __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   // Arithmetic op= operations involving two complex arguments.
williamr@2: 
williamr@2:   static void  _STLP_CALL _div(const value_type& __z1_r, const value_type& __z1_i,
williamr@4:                                const value_type& __z2_r, const value_type& __z2_i,
williamr@4:                                value_type& __res_r, value_type& __res_i);
williamr@2: 
williamr@4:   static void _STLP_CALL _div(const value_type& __z1_r,
williamr@4:                               const value_type& __z2_r, const value_type& __z2_i,
williamr@4:                               value_type& __res_r, value_type& __res_i);
williamr@2: 
williamr@4: #if defined (_STLP_MEMBER_TEMPLATES) // && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
williamr@2: 
williamr@2:   template <class _Tp2> _Self& operator+= (const complex<_Tp2>& __z) {
williamr@2:     _M_re += __z._M_re;
williamr@2:     _M_im += __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2> _Self& operator-= (const complex<_Tp2>& __z) {
williamr@2:     _M_re -= __z._M_re;
williamr@2:     _M_im -= __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2> _Self& operator*= (const complex<_Tp2>& __z) {
williamr@2:     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
williamr@2:     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2> _Self& operator/= (const complex<_Tp2>& __z) {
williamr@2:     value_type __r;
williamr@2:     value_type __i;
williamr@2:     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: #endif /* _STLP_MEMBER_TEMPLATES */
williamr@2: 
williamr@2:   _Self& operator+= (const _Self& __z) {
williamr@2:     _M_re += __z._M_re;
williamr@2:     _M_im += __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   _Self& operator-= (const _Self& __z) {
williamr@2:     _M_re -= __z._M_re;
williamr@2:     _M_im -= __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@4: 
williamr@2:   _Self& operator*= (const _Self& __z) {
williamr@2:     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
williamr@2:     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   _Self& operator/= (const _Self& __z) {
williamr@2:     value_type __r;
williamr@2:     value_type __i;
williamr@2:     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   // Data members.
williamr@2:   value_type _M_re;
williamr@2:   value_type _M_im;
williamr@2: };
williamr@2: 
williamr@4: #if !defined (_STLP_NO_COMPLEX_SPECIALIZATIONS)    //*TY 02/25/2000 - added for MPW compiler workaround
williamr@2: // Explicit specializations for float, double, long double.  The only
williamr@2: // reason for these specializations is to enable automatic conversions
williamr@2: // from complex<float> to complex<double>, and complex<double> to
williamr@2: // complex<long double>.
williamr@2: 
williamr@2: _STLP_TEMPLATE_NULL
williamr@2: struct _STLP_CLASS_DECLSPEC complex<float> {
williamr@2:   typedef float value_type;
williamr@2:   typedef complex<float> _Self;
williamr@2:   // Constructors, destructor, assignment operator.
williamr@2: 
williamr@4:   complex(value_type __x = 0.0f, value_type __y = 0.0f)
williamr@2:     : _M_re(__x), _M_im(__y) {}
williamr@2: 
williamr@4:   complex(const complex<float>& __z)    : _M_re(__z._M_re), _M_im(__z._M_im) {}
williamr@2: 
williamr@2:   inline explicit complex(const complex<double>& __z);
williamr@4: #  ifndef _STLP_NO_LONG_DOUBLE
williamr@2:   inline explicit complex(const complex<long double>& __z);
williamr@4: #  endif
williamr@2:   // Element access.
williamr@2:   value_type real() const { return _M_re; }
williamr@2:   value_type imag() const { return _M_im; }
williamr@2: 
williamr@2:   // Arithmetic op= operations involving one real argument.
williamr@2: 
williamr@2:   _Self& operator= (value_type __x) {
williamr@2:     _M_re = __x;
williamr@4:     _M_im = 0.0f;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator+= (value_type __x) {
williamr@2:     _M_re += __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator-= (value_type __x) {
williamr@2:     _M_re -= __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator*= (value_type __x) {
williamr@2:     _M_re *= __x;
williamr@2:     _M_im *= __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator/= (value_type __x) {
williamr@2:     _M_re /= __x;
williamr@2:     _M_im /= __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   // Arithmetic op= operations involving two complex arguments.
williamr@2: 
williamr@4:   _STLP_DECLSPEC static void _STLP_CALL _div(const float& __z1_r, const float& __z1_i,
williamr@2:                               const float& __z2_r, const float& __z2_i,
williamr@2:                               float& __res_r, float& __res_i);
williamr@4: 
williamr@4:   _STLP_DECLSPEC static void _STLP_CALL _div(const float& __z1_r,
williamr@2:                               const float& __z2_r, const float& __z2_i,
williamr@2:                               float& __res_r, float& __res_i);
williamr@2: 
williamr@4: #  if defined (_STLP_MEMBER_TEMPLATES)
williamr@2:   template <class _Tp2>
williamr@2:   complex<float>& operator=(const complex<_Tp2>& __z) {
williamr@2:     _M_re = __z._M_re;
williamr@2:     _M_im = __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   complex<float>& operator+= (const complex<_Tp2>& __z) {
williamr@2:     _M_re += __z._M_re;
williamr@2:     _M_im += __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   complex<float>& operator-= (const complex<_Tp2>& __z) {
williamr@2:     _M_re -= __z._M_re;
williamr@2:     _M_im -= __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   complex<float>& operator*= (const complex<_Tp2>& __z) {
williamr@2:     float __r = _M_re * __z._M_re - _M_im * __z._M_im;
williamr@2:     float __i = _M_re * __z._M_im + _M_im * __z._M_re;
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   complex<float>& operator/= (const complex<_Tp2>& __z) {
williamr@2:     float __r;
williamr@2:     float __i;
williamr@2:     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@4: #  endif /* _STLP_MEMBER_TEMPLATES */
williamr@2: 
williamr@2:   _Self& operator=(const _Self& __z) {
williamr@2:     _M_re = __z._M_re;
williamr@2:     _M_im = __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   _Self& operator+= (const _Self& __z) {
williamr@2:     _M_re += __z._M_re;
williamr@2:     _M_im += __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   _Self& operator-= (const _Self& __z) {
williamr@2:     _M_re -= __z._M_re;
williamr@2:     _M_im -= __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@4: 
williamr@2:   _Self& operator*= (const _Self& __z) {
williamr@2:     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
williamr@2:     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   _Self& operator/= (const _Self& __z) {
williamr@2:     value_type __r;
williamr@2:     value_type __i;
williamr@2:     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   // Data members.
williamr@2:   value_type _M_re;
williamr@2:   value_type _M_im;
williamr@2: };
williamr@2: 
williamr@4: _STLP_TEMPLATE_NULL
williamr@4: struct _STLP_CLASS_DECLSPEC complex<double> {
williamr@2:   typedef double value_type;
williamr@2:   typedef complex<double> _Self;
williamr@2: 
williamr@2:   // Constructors, destructor, assignment operator.
williamr@2: 
williamr@2:   complex(value_type __x = 0.0, value_type __y = 0.0)
williamr@2:     : _M_re(__x), _M_im(__y) {}
williamr@2: 
williamr@2:   complex(const complex<double>& __z)
williamr@2:     : _M_re(__z._M_re), _M_im(__z._M_im) {}
williamr@2:   inline complex(const complex<float>& __z);
williamr@4: #  if !defined (_STLP_NO_LONG_DOUBLE)
williamr@2:   explicit inline complex(const complex<long double>& __z);
williamr@4: #  endif
williamr@2:   // Element access.
williamr@2:   value_type real() const { return _M_re; }
williamr@2:   value_type imag() const { return _M_im; }
williamr@2: 
williamr@2:   // Arithmetic op= operations involving one real argument.
williamr@2: 
williamr@2:   _Self& operator= (value_type __x) {
williamr@2:     _M_re = __x;
williamr@4:     _M_im = 0.0;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator+= (value_type __x) {
williamr@2:     _M_re += __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator-= (value_type __x) {
williamr@2:     _M_re -= __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator*= (value_type __x) {
williamr@2:     _M_re *= __x;
williamr@2:     _M_im *= __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator/= (value_type __x) {
williamr@2:     _M_re /= __x;
williamr@2:     _M_im /= __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   // Arithmetic op= operations involving two complex arguments.
williamr@2: 
williamr@2:   _STLP_DECLSPEC static void _STLP_CALL _div(const double& __z1_r, const double& __z1_i,
williamr@2:                               const double& __z2_r, const double& __z2_i,
williamr@2:                               double& __res_r, double& __res_i);
williamr@4:   _STLP_DECLSPEC static void _STLP_CALL _div(const double& __z1_r,
williamr@2:                               const double& __z2_r, const double& __z2_i,
williamr@2:                               double& __res_r, double& __res_i);
williamr@2: 
williamr@4: #  if defined (_STLP_MEMBER_TEMPLATES) && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
williamr@2:   template <class _Tp2>
williamr@2:   complex<double>& operator=(const complex<_Tp2>& __z) {
williamr@2:     _M_re = __z._M_re;
williamr@2:     _M_im = __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   complex<double>& operator+= (const complex<_Tp2>& __z) {
williamr@2:     _M_re += __z._M_re;
williamr@2:     _M_im += __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   complex<double>& operator-= (const complex<_Tp2>& __z) {
williamr@2:     _M_re -= __z._M_re;
williamr@2:     _M_im -= __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   complex<double>& operator*= (const complex<_Tp2>& __z) {
williamr@2:     double __r = _M_re * __z._M_re - _M_im * __z._M_im;
williamr@2:     double __i = _M_re * __z._M_im + _M_im * __z._M_re;
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   complex<double>& operator/= (const complex<_Tp2>& __z) {
williamr@2:     double __r;
williamr@2:     double __i;
williamr@2:     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@4: #  endif /* _STLP_MEMBER_TEMPLATES */
williamr@2: 
williamr@2:   _Self& operator=(const _Self& __z) {
williamr@2:     _M_re = __z._M_re;
williamr@2:     _M_im = __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   _Self& operator+= (const _Self& __z) {
williamr@2:     _M_re += __z._M_re;
williamr@2:     _M_im += __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   _Self& operator-= (const _Self& __z) {
williamr@2:     _M_re -= __z._M_re;
williamr@2:     _M_im -= __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@4: 
williamr@2:   _Self& operator*= (const _Self& __z) {
williamr@2:     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
williamr@2:     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   _Self& operator/= (const _Self& __z) {
williamr@2:     value_type __r;
williamr@2:     value_type __i;
williamr@2:     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   // Data members.
williamr@2:   value_type _M_re;
williamr@2:   value_type _M_im;
williamr@2: };
williamr@2: 
williamr@4: #  if !defined (_STLP_NO_LONG_DOUBLE)
williamr@2: 
williamr@4: _STLP_TEMPLATE_NULL
williamr@4: struct _STLP_CLASS_DECLSPEC complex<long double> {
williamr@2:   typedef long double value_type;
williamr@2:   typedef complex<long double> _Self;
williamr@2: 
williamr@2:   // Constructors, destructor, assignment operator.
williamr@4:   complex(value_type __x = 0.0l, value_type __y = 0.0l)
williamr@2:     : _M_re(__x), _M_im(__y) {}
williamr@2: 
williamr@2:   complex(const complex<long double>& __z)
williamr@2:     : _M_re(__z._M_re), _M_im(__z._M_im) {}
williamr@2:   inline complex(const complex<float>& __z);
williamr@2:   inline complex(const complex<double>& __z);
williamr@2: 
williamr@2:   // Element access.
williamr@2:   value_type real() const { return _M_re; }
williamr@2:   value_type imag() const { return _M_im; }
williamr@2: 
williamr@2:   // Arithmetic op= operations involving one real argument.
williamr@2: 
williamr@2:   _Self& operator= (value_type __x) {
williamr@2:     _M_re = __x;
williamr@4:     _M_im = 0.0l;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator+= (value_type __x) {
williamr@2:     _M_re += __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator-= (value_type __x) {
williamr@2:     _M_re -= __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator*= (value_type __x) {
williamr@2:     _M_re *= __x;
williamr@2:     _M_im *= __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2:   _Self& operator/= (value_type __x) {
williamr@2:     _M_re /= __x;
williamr@2:     _M_im /= __x;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   // Arithmetic op= operations involving two complex arguments.
williamr@2: 
williamr@2:   _STLP_DECLSPEC static void _STLP_CALL _div(const long double& __z1_r, const long double& __z1_i,
williamr@2:                               const long double& __z2_r, const long double& __z2_i,
williamr@2:                               long double& __res_r, long double& __res_i);
williamr@2: 
williamr@4:   _STLP_DECLSPEC static void _STLP_CALL _div(const long double& __z1_r,
williamr@2:                               const long double& __z2_r, const long double& __z2_i,
williamr@2:                               long double& __res_r, long double& __res_i);
williamr@2: 
williamr@4: #    if defined (_STLP_MEMBER_TEMPLATES) && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   complex<long double>& operator=(const complex<_Tp2>& __z) {
williamr@2:     _M_re = __z._M_re;
williamr@2:     _M_im = __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   complex<long double>& operator+= (const complex<_Tp2>& __z) {
williamr@2:     _M_re += __z._M_re;
williamr@2:     _M_im += __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   complex<long double>& operator-= (const complex<_Tp2>& __z) {
williamr@2:     _M_re -= __z._M_re;
williamr@2:     _M_im -= __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   complex<long double>& operator*= (const complex<_Tp2>& __z) {
williamr@2:     long double __r = _M_re * __z._M_re - _M_im * __z._M_im;
williamr@2:     long double __i = _M_re * __z._M_im + _M_im * __z._M_re;
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   template <class _Tp2>
williamr@2:   complex<long double>& operator/= (const complex<_Tp2>& __z) {
williamr@2:     long double __r;
williamr@2:     long double __i;
williamr@2:     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@4: #    endif /* _STLP_MEMBER_TEMPLATES */
williamr@2: 
williamr@2:   _Self& operator=(const _Self& __z) {
williamr@2:     _M_re = __z._M_re;
williamr@2:     _M_im = __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   _Self& operator+= (const _Self& __z) {
williamr@2:     _M_re += __z._M_re;
williamr@2:     _M_im += __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   _Self& operator-= (const _Self& __z) {
williamr@2:     _M_re -= __z._M_re;
williamr@2:     _M_im -= __z._M_im;
williamr@2:     return *this;
williamr@2:   }
williamr@4: 
williamr@2:   _Self& operator*= (const _Self& __z) {
williamr@2:     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
williamr@2:     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   _Self& operator/= (const _Self& __z) {
williamr@2:     value_type __r;
williamr@2:     value_type __i;
williamr@2:     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
williamr@2:     _M_re = __r;
williamr@2:     _M_im = __i;
williamr@2:     return *this;
williamr@2:   }
williamr@2: 
williamr@2:   // Data members.
williamr@2:   value_type _M_re;
williamr@2:   value_type _M_im;
williamr@2: };
williamr@2: 
williamr@4: #  endif /* _STLP_NO_LONG_DOUBLE */
williamr@2: 
williamr@2: // Converting constructors from one of these three specialized types
williamr@2: // to another.
williamr@2: 
williamr@2: inline complex<float>::complex(const complex<double>& __z)
williamr@4:   : _M_re((float)__z._M_re), _M_im((float)__z._M_im) {}
williamr@2: inline complex<double>::complex(const complex<float>& __z)
williamr@2:   : _M_re(__z._M_re), _M_im(__z._M_im) {}
williamr@4: #  ifndef _STLP_NO_LONG_DOUBLE
williamr@2: inline complex<float>::complex(const complex<long double>& __z)
williamr@4:   : _M_re((float)__z._M_re), _M_im((float)__z._M_im) {}
williamr@2: inline complex<double>::complex(const complex<long double>& __z)
williamr@4:   : _M_re((double)__z._M_re), _M_im((double)__z._M_im) {}
williamr@2: inline complex<long double>::complex(const complex<float>& __z)
williamr@2:   : _M_re(__z._M_re), _M_im(__z._M_im) {}
williamr@2: inline complex<long double>::complex(const complex<double>& __z)
williamr@2:   : _M_re(__z._M_re), _M_im(__z._M_im) {}
williamr@4: #  endif
williamr@2: 
williamr@4: #endif /* SPECIALIZATIONS */
williamr@2: 
williamr@2: // Unary non-member arithmetic operators.
williamr@2: 
williamr@2: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL operator+(const complex<_Tp>& __z)
williamr@4: { return __z; }
williamr@2: 
williamr@2: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL  operator-(const complex<_Tp>& __z)
williamr@4: { return complex<_Tp>(-__z._M_re, -__z._M_im); }
williamr@2: 
williamr@2: // Non-member arithmetic operations involving one real argument.
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL operator+(const _Tp& __x, const complex<_Tp>& __z)
williamr@4: { return complex<_Tp>(__x + __z._M_re, __z._M_im); }
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL operator+(const complex<_Tp>& __z, const _Tp& __x)
williamr@4: { return complex<_Tp>(__z._M_re + __x, __z._M_im); }
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL operator-(const _Tp& __x, const complex<_Tp>& __z)
williamr@4: { return complex<_Tp>(__x - __z._M_re, -__z._M_im); }
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL operator-(const complex<_Tp>& __z, const _Tp& __x)
williamr@4: { return complex<_Tp>(__z._M_re - __x, __z._M_im); }
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL operator*(const _Tp& __x, const complex<_Tp>& __z)
williamr@4: { return complex<_Tp>(__x * __z._M_re, __x * __z._M_im); }
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL operator*(const complex<_Tp>& __z, const _Tp& __x)
williamr@4: { return complex<_Tp>(__z._M_re * __x, __z._M_im * __x); }
williamr@2: 
williamr@4: template <class _Tp>
williamr@2: inline complex<_Tp> _STLP_CALL operator/(const _Tp& __x, const complex<_Tp>& __z) {
williamr@2:   complex<_Tp> __result;
williamr@2:   complex<_Tp>::_div(__x,
williamr@2:                      __z._M_re, __z._M_im,
williamr@2:                      __result._M_re, __result._M_im);
williamr@2:   return __result;
williamr@2: }
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL operator/(const complex<_Tp>& __z, const _Tp& __x)
williamr@4: { return complex<_Tp>(__z._M_re / __x, __z._M_im / __x); }
williamr@2: 
williamr@2: // Non-member arithmetic operations involving two complex arguments
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL
williamr@4: operator+(const complex<_Tp>& __z1, const complex<_Tp>& __z2)
williamr@4: { return complex<_Tp>(__z1._M_re + __z2._M_re, __z1._M_im + __z2._M_im); }
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL
williamr@4: operator-(const complex<_Tp>& __z1, const complex<_Tp>& __z2)
williamr@4: { return complex<_Tp>(__z1._M_re - __z2._M_re, __z1._M_im - __z2._M_im); }
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL
williamr@2: operator*(const complex<_Tp>& __z1, const complex<_Tp>& __z2) {
williamr@2:   return complex<_Tp>(__z1._M_re * __z2._M_re - __z1._M_im * __z2._M_im,
williamr@2:                       __z1._M_re * __z2._M_im + __z1._M_im * __z2._M_re);
williamr@2: }
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL
williamr@2: operator/(const complex<_Tp>& __z1, const complex<_Tp>& __z2) {
williamr@2:   complex<_Tp> __result;
williamr@2:   complex<_Tp>::_div(__z1._M_re, __z1._M_im,
williamr@2:                      __z2._M_re, __z2._M_im,
williamr@2:                      __result._M_re, __result._M_im);
williamr@2:   return __result;
williamr@2: }
williamr@2: 
williamr@2: // Comparison operators.
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline bool _STLP_CALL operator==(const complex<_Tp>& __z1, const complex<_Tp>& __z2)
williamr@4: { return __z1._M_re == __z2._M_re && __z1._M_im == __z2._M_im; }
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline bool _STLP_CALL operator==(const complex<_Tp>& __z, const _Tp& __x)
williamr@4: { return __z._M_re == __x && __z._M_im == 0; }
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline bool _STLP_CALL operator==(const _Tp& __x, const complex<_Tp>& __z)
williamr@4: { return __x == __z._M_re && 0 == __z._M_im; }
williamr@2: 
williamr@4: //04/27/04 dums: removal of this check, if it is restablish
williamr@4: //please explain why the other operators are not macro guarded
williamr@4: //#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline bool _STLP_CALL operator!=(const complex<_Tp>& __z1, const complex<_Tp>& __z2)
williamr@4: { return __z1._M_re != __z2._M_re || __z1._M_im != __z2._M_im; }
williamr@2: 
williamr@4: //#endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline bool _STLP_CALL operator!=(const complex<_Tp>& __z, const _Tp& __x)
williamr@4: { return __z._M_re != __x || __z._M_im != 0; }
williamr@2: 
williamr@4: template <class _Tp>
williamr@4: inline bool _STLP_CALL operator!=(const _Tp& __x, const complex<_Tp>& __z)
williamr@4: { return __x != __z._M_re || 0 != __z._M_im; }
williamr@2: 
williamr@2: // Other basic arithmetic operations
williamr@2: template <class _Tp>
williamr@4: inline _Tp _STLP_CALL real(const complex<_Tp>& __z)
williamr@4: { return __z._M_re; }
williamr@2: 
williamr@2: template <class _Tp>
williamr@4: inline _Tp _STLP_CALL imag(const complex<_Tp>& __z)
williamr@4: { return __z._M_im; }
williamr@4: 
williamr@4: #if defined(__SYMBIAN32__) && defined (_STLP_DESIGNATED_DLL) && (__ARMCC_VERSION >= 220435 && __ARMCC_VERSION < 230000) //RVCT 2.2, __declspec(dllexport) should be there at declaration
williamr@4: template <class _Tp>
williamr@4: _Tp _STLP_CALL _STLP_DECLSPEC abs(const complex<_Tp>& __z);
williamr@2: 
williamr@2: template <class _Tp>
williamr@4: _Tp _STLP_CALL _STLP_DECLSPEC arg(const complex<_Tp>& __z);
williamr@4: #else
williamr@4: template <class _Tp>
williamr@4: _Tp _STLP_CALL abs(const complex<_Tp>& __z);
williamr@4: 
williamr@4: template <class _Tp>
williamr@4: _Tp _STLP_CALL arg(const complex<_Tp>& __z);
williamr@4: #endif //__SYMBIAN32__ && _STLP_DESIGNATED_DLL
williamr@4: 
williamr@4: template <class _Tp>
williamr@4: inline _Tp _STLP_CALL norm(const complex<_Tp>& __z)
williamr@4: { return __z._M_re * __z._M_re + __z._M_im * __z._M_im; }
williamr@4: 
williamr@4: template <class _Tp>
williamr@4: inline complex<_Tp> _STLP_CALL conj(const complex<_Tp>& __z)
williamr@4: { return complex<_Tp>(__z._M_re, -__z._M_im); }
williamr@4: 
williamr@4: template <class _Tp>
williamr@4: complex<_Tp> _STLP_CALL polar(const _Tp& __rho)
williamr@4: { return complex<_Tp>(__rho, 0); }
williamr@4: 
williamr@4: #if defined(__SYMBIAN32__) && defined (_STLP_DESIGNATED_DLL)  && (__ARMCC_VERSION >= 220435 && __ARMCC_VERSION < 230000)
williamr@4: template <class _Tp>
williamr@4: complex<_Tp> _STLP_CALL _STLP_DECLSPEC polar(const _Tp& __rho, const _Tp& __phi);
williamr@4: #else
williamr@4: template <class _Tp>
williamr@4: complex<_Tp> _STLP_CALL polar(const _Tp& __rho, const _Tp& __phi);
williamr@4: #endif //__SYMBIAN32__ && _STLP_DESIGNATED_DLL
williamr@4: 
williamr@4: 
williamr@4: _STLP_TEMPLATE_NULL
williamr@4: _STLP_DECLSPEC float _STLP_CALL abs(const complex<float>&);
williamr@4: _STLP_TEMPLATE_NULL
williamr@4: _STLP_DECLSPEC double _STLP_CALL abs(const complex<double>&);
williamr@4: _STLP_TEMPLATE_NULL
williamr@4: _STLP_DECLSPEC float _STLP_CALL arg(const complex<float>&);
williamr@4: _STLP_TEMPLATE_NULL
williamr@4: _STLP_DECLSPEC double _STLP_CALL arg(const complex<double>&);
williamr@4: _STLP_TEMPLATE_NULL
williamr@4: _STLP_DECLSPEC complex<float> _STLP_CALL polar(const float& __rho, const float& __phi);
williamr@4: _STLP_TEMPLATE_NULL
williamr@4: _STLP_DECLSPEC complex<double> _STLP_CALL polar(const double& __rho, const double& __phi);
williamr@2: 
williamr@2: template <class _Tp>
williamr@2: _Tp _STLP_CALL abs(const complex<_Tp>& __z)
williamr@4: { return _Tp(abs(complex<double>(double(__z.real()), double(__z.imag())))); }
williamr@2: 
williamr@2: template <class _Tp>
williamr@2: _Tp _STLP_CALL arg(const complex<_Tp>& __z)
williamr@4: { return _Tp(arg(complex<double>(double(__z.real()), double(__z.imag())))); }
williamr@2: 
williamr@2: template <class _Tp>
williamr@2: complex<_Tp> _STLP_CALL polar(const _Tp& __rho, const _Tp& __phi) {
williamr@2:   complex<double> __tmp = polar(double(__rho), double(__phi));
williamr@2:   return complex<_Tp>(_Tp(__tmp.real()), _Tp(__tmp.imag()));
williamr@2: }
williamr@2: 
williamr@4: #if !defined (_STLP_NO_LONG_DOUBLE)
williamr@2: _STLP_TEMPLATE_NULL
williamr@4: _STLP_DECLSPEC long double _STLP_CALL arg(const complex<long double>&);
williamr@2: _STLP_TEMPLATE_NULL
williamr@4: _STLP_DECLSPEC long double _STLP_CALL abs(const complex<long double>&);
williamr@2: _STLP_TEMPLATE_NULL
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL polar(const long double&, const long double&);
williamr@2: #endif
williamr@2: 
williamr@2: 
williamr@4: #if !defined (_STLP_USE_NO_IOSTREAMS)
williamr@2: 
williamr@4: _STLP_END_NAMESPACE
williamr@4: 
williamr@4: #  include <iosfwd>
williamr@4: 
williamr@4: _STLP_BEGIN_NAMESPACE
williamr@4: 
williamr@4: // Complex output, in the form (re,im).  We use a two-step process
williamr@4: // involving stringstream so that we get the padding right.
williamr@2: template <class _Tp, class _CharT, class _Traits>
williamr@4: basic_ostream<_CharT, _Traits>&  _STLP_CALL
williamr@2: operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __z);
williamr@2: 
williamr@2: template <class _Tp, class _CharT, class _Traits>
williamr@4: basic_istream<_CharT, _Traits>& _STLP_CALL
williamr@2: operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __z);
williamr@2: 
williamr@2: // Specializations for narrow characters; lets us avoid widen.
williamr@2: 
williamr@2: _STLP_OPERATOR_TEMPLATE
williamr@4: _STLP_DECLSPEC basic_istream<char, char_traits<char> >& _STLP_CALL
williamr@2: operator>>(basic_istream<char, char_traits<char> >& __is, complex<float>& __z);
williamr@2: 
williamr@2: _STLP_OPERATOR_TEMPLATE
williamr@4: _STLP_DECLSPEC basic_istream<char, char_traits<char> >& _STLP_CALL
williamr@2: operator>>(basic_istream<char, char_traits<char> >& __is, complex<double>& __z);
williamr@2: 
williamr@2: _STLP_OPERATOR_TEMPLATE
williamr@4: _STLP_DECLSPEC basic_ostream<char, char_traits<char> >& _STLP_CALL
williamr@2: operator<<(basic_ostream<char, char_traits<char> >& __is, const complex<float>& __z);
williamr@2: 
williamr@2: _STLP_OPERATOR_TEMPLATE
williamr@4: _STLP_DECLSPEC basic_ostream<char, char_traits<char> >& _STLP_CALL
williamr@2: operator<<(basic_ostream<char, char_traits<char> >& __is, const complex<double>& __z);
williamr@2: 
williamr@4: #  if !defined (_STLP_NO_LONG_DOUBLE)
williamr@2: _STLP_OPERATOR_TEMPLATE
williamr@4: _STLP_DECLSPEC basic_istream<char, char_traits<char> >& _STLP_CALL
williamr@2: operator>>(basic_istream<char, char_traits<char> >& __is, complex<long double>& __z);
williamr@2: 
williamr@2: _STLP_OPERATOR_TEMPLATE
williamr@4: _STLP_DECLSPEC basic_ostream<char, char_traits<char> >& _STLP_CALL
williamr@2: operator<<(basic_ostream<char, char_traits<char> >& __is, const complex<long double>& __z);
williamr@2: 
williamr@2: #  endif
williamr@2: 
williamr@4: #  if defined (_STLP_USE_TEMPLATE_EXPORT) && ! defined (_STLP_NO_WCHAR_T)
williamr@2: 
williamr@4: _STLP_EXPORT_TEMPLATE basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
williamr@4: operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<double>&);
williamr@4: _STLP_EXPORT_TEMPLATE basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
williamr@4: operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<double>&);
williamr@4: _STLP_EXPORT_TEMPLATE basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
williamr@4: operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<float>&);
williamr@4: _STLP_EXPORT_TEMPLATE basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
williamr@4: operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<float>&);
williamr@2: 
williamr@4: #    if !defined (_STLP_NO_LONG_DOUBLE)
williamr@4: _STLP_EXPORT_TEMPLATE basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
williamr@4: operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<long double>&);
williamr@4: _STLP_EXPORT_TEMPLATE basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
williamr@4: operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<long double>&);
williamr@4: #    endif
williamr@4: #  endif
williamr@4: #endif
williamr@2: 
williamr@2: 
williamr@4: // Transcendental functions.  These are defined only for float,
williamr@2: //  double, and long double.  (Sqrt isn't transcendental, of course,
williamr@2: //  but it's included in this section anyway.)
williamr@2: 
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL sqrt(const complex<float>&);
williamr@2: 
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL exp(const complex<float>&);
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL  log(const complex<float>&);
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL log10(const complex<float>&);
williamr@2: 
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>&, int);
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>&, const float&);
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL pow(const float&, const complex<float>&);
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>&, const complex<float>&);
williamr@2: 
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL sin(const complex<float>&);
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL cos(const complex<float>&);
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL tan(const complex<float>&);
williamr@2: 
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL sinh(const complex<float>&);
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL cosh(const complex<float>&);
williamr@2: _STLP_DECLSPEC complex<float> _STLP_CALL tanh(const complex<float>&);
williamr@2: 
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL sqrt(const complex<double>&);
williamr@2: 
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL exp(const complex<double>&);
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL log(const complex<double>&);
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL log10(const complex<double>&);
williamr@2: 
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>&, int);
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>&, const double&);
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL pow(const double&, const complex<double>&);
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>&, const complex<double>&);
williamr@2: 
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL sin(const complex<double>&);
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL cos(const complex<double>&);
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL tan(const complex<double>&);
williamr@2: 
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL sinh(const complex<double>&);
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL cosh(const complex<double>&);
williamr@2: _STLP_DECLSPEC complex<double> _STLP_CALL tanh(const complex<double>&);
williamr@2: 
williamr@4: #if !defined (_STLP_NO_LONG_DOUBLE)
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL sqrt(const complex<long double>&);
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL exp(const complex<long double>&);
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL log(const complex<long double>&);
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL log10(const complex<long double>&);
williamr@2: 
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>&, int);
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>&, const long double&);
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const long double&, const complex<long double>&);
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>&,
williamr@2:                                                    const complex<long double>&);
williamr@2: 
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL sin(const complex<long double>&);
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL cos(const complex<long double>&);
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL tan(const complex<long double>&);
williamr@2: 
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL sinh(const complex<long double>&);
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL cosh(const complex<long double>&);
williamr@2: _STLP_DECLSPEC complex<long double> _STLP_CALL tanh(const complex<long double>&);
williamr@4: #endif
williamr@2: 
williamr@2: _STLP_END_NAMESPACE
williamr@2: 
williamr@4: #ifndef _STLP_LINK_TIME_INSTANTIATION
williamr@2: #  include <stl/_complex.c>
williamr@4: #endif
williamr@2: 
williamr@4: #endif
williamr@2: 
williamr@2: // Local Variables:
williamr@2: // mode:C++
williamr@2: // End: