#ifndef __STD_COMPLEX #define __STD_COMPLEX // // // Copyright Digital Equipment Corporation 1996. All rights reserved. // // Restricted Rights: Use, duplication, or disclosure by the U.S. // Government is subject to restrictions as set forth in subparagraph // (c) (1) (ii) of DFARS 252.227-7013, or in FAR 52.227-19, or in FAR // 52.227-14 Alt. III, as applicable. // // This software is proprietary to and embodies the confidential // technology of Digital Equipment Corporation. Possession, use, or // copying of this software and media is authorized only pursuant to a // valid written license from Digital or an authorized sublicensor. // // /*************************************************************************** * * complex - Declaration for the Standard Library complex class * * $Id: complex,v 1.99 1996/09/27 07:49:07 smithey Exp $ * *************************************************************************** * * (c) Copyright 1994-1996 Rogue Wave Software, Inc. * ALL RIGHTS RESERVED * * The software and information contained herein are proprietary to, and * comprise valuable trade secrets of, Rogue Wave Software, Inc., which * intends to preserve as trade secrets such software and information. * This software is furnished pursuant to a written license agreement and * may be used, copied, transmitted, and stored only in accordance with * the terms of such license and with the inclusion of the above copyright * notice. This software and information or any other copies thereof may * not be provided or otherwise made available to any other person. * * Notwithstanding any other lease or license that may pertain to, or * accompany the delivery of, this computer software and information, the * rights of the Government regarding its use, reproduction and disclosure * are as set forth in Section 52.227-19 of the FARS Computer * Software-Restricted Rights clause. * * Use, duplication, or disclosure by the Government is subject to * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in * Technical Data and Computer Software clause at DFARS 252.227-7013. * Contractor/Manufacturer is Rogue Wave Software, Inc., * P.O. Box 2328, Corvallis, Oregon 97339. * * This computer software and information is distributed with "restricted * rights." Use, duplication or disclosure is subject to restrictions as * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial * Computer Software-Restricted Rights (April 1985)." If the Clause at * 18-52.227-74 "Rights in Data General" is specified in the contract, * then the "Alternate III" clause applies. * **************************************************************************/ #include #include #include #ifndef _RWSTD_HEADER_REQUIRES_HPP #include #else #include #endif #ifndef __USE_STD_IOSTREAM #include #else #include #endif #if defined(__DECCXX) # ifdef __PRAGMA_ENVIRONMENT # pragma __environment __save # pragma __environment __header_defaults # endif #endif #ifndef _RWSTD_NO_NAMESPACE namespace std { #endif #ifdef _RWSTD_NO_FO_RWARD_SPECIALIZATIONS template class _RWSTDExportTemplate complex { public: typedef T value_type; complex (const T& re_arg=0, const T& imag_arg=0) { re_=re_arg; im_=imag_arg; } ~complex() { ; } T imag () const { return im_; } T real () const { return re_; } #ifndef _RWSTD_NO_MEMBER_TEMPLATES template complex (const complex& rhs) {re_=rhs.real(); im_=rhs.imag();} template complex& operator= (const complex& rhs) {re_=rhs.real(); im_=rhs.imag(); return *this;} template complex& operator+= (const complex& rhs) {re_+=rhs.real(); im_+=rhs.imag(); return *this;} template complex& operator-= (const complex& rhs) {re_-=rhs.real(); im_-=rhs.imag(); return *this;} template complex& operator*= (const complex& rhs) {T tmp=re_*rhs.real()-im_*rhs.imag(); im_=im_*rhs.real()+re_*rhs.imag(); re_=tmp; return *this;} template complex& operator/= (const complex&); #endif complex& operator= (T); complex& operator+= (T); complex& operator-= (T); complex& operator*= (T); complex& operator/= (T); private: T re_, im_; }; #else // // The complex template definition must be placed after specializations to // satisfy several compilers' rather bizarre preference. // template class _RWSTDExportTemplate complex; #endif #ifndef _RWSTD_NO_FO_RWARD_SPECIALIZATIONS #if defined(__DECCXX) && !defined(__DECFIXCXXL508) template <> #endif class _RWSTDExport complex; #if defined(__DECCXX) && !defined(__DECFIXCXXL508) template <> #endif class _RWSTDExport complex; #ifndef _RWSTD_NO_LONGDOUBLE #if defined(__DECCXX) && !defined(__DECFIXCXXL508) template <> #endif class _RWSTDExport complex; #endif #endif #if defined(__DECCXX) && !defined(__DECFIXCXXL508) template <> #endif class _RWSTDExport complex { public: typedef float value_type; complex (const float& re_arg=0.0f, const float& imag_arg=0.0f) { re_=re_arg; im_=imag_arg; } complex (const complex&); #ifndef _RWSTD_NO_FO_RWARD_SPECIALIZATIONS _EXPLICIT complex (const complex&); #ifndef _RWSTD_NO_LONGDOUBLE _EXPLICIT complex (const complex&); #endif #endif ~complex() { ; } float imag () const { return im_; } float real () const { return re_; } #ifndef _RWSTD_NO_MEMBER_TEMPLATES template complex& operator= (const complex& rhs) {re_=rhs.real(); im_=rhs.imag(); return *this;} template complex& operator+= (const complex& rhs) {re_+=rhs.real(); im_+=rhs.imag(); return *this;} template complex& operator-= (const complex& rhs) {re_-=rhs.real(); im_-=rhs.imag(); return *this;} template complex& operator*= (const complex& rhs) {float tmp=re_*rhs.real()-im_*rhs.imag(); im_=im_*rhs.real()+re_*rhs.imag(); re_=tmp; return *this;} template complex& operator/= (const complex&); #else /* Have to specialize each one :-( */ complex& operator= (const complex&); complex& operator+= (const complex&); complex& operator-= (const complex&); complex& operator*= (const complex&); complex& operator/= (const complex&); #ifndef _RWSTD_NO_FO_RWARD_SPECIALIZATIONS complex& operator= (const complex&); complex& operator+= (const complex&); complex& operator-= (const complex&); complex& operator*= (const complex&); complex& operator/= (const complex&); #ifndef _RWSTD_NO_LONGDOUBLE complex& operator= (const complex&); complex& operator+= (const complex&); complex& operator-= (const complex&); complex& operator*= (const complex&); complex& operator/= (const complex&); #endif #endif #endif complex& operator= (float); complex& operator+= (float); complex& operator-= (float); complex& operator*= (float); complex& operator/= (float); private: float re_, im_; }; #if defined(__DECCXX) && !defined(__DECFIXCXXL508) template <> #endif class _RWSTDExport complex { public: typedef double value_type; complex (const double& re_arg=0.0, const double& imag_arg=0.0) { re_=re_arg; im_=imag_arg; } complex (const complex&); complex (const complex&); #ifndef _RWSTD_NO_FO_RWARD_SPECIALIZATIONS #ifndef _RWSTD_NO_LONGDOUBLE _EXPLICIT complex (const complex&); #endif #endif ~complex() { ; } double imag () const { return im_; } double real () const { return re_; } #ifndef _RWSTD_NO_MEMBER_TEMPLATES template complex& operator= (const complex& rhs) {re_=rhs.real(); im_=rhs.imag(); return *this;} template complex& operator+= (const complex& rhs) {re_+=rhs.real(); im_+=rhs.imag(); return *this;} template complex& operator-= (const complex& rhs) {re_-=rhs.real(); im_-=rhs.imag(); return *this;} template complex& operator*= (const complex& rhs) {double tmp=re_*rhs.real()-im_*rhs.imag(); im_=im_*rhs.real()+re_*rhs.imag(); re_=tmp; return *this;} template complex& operator/= (const complex&); #else /* Have to specialize each one :-( */ complex& operator= (const complex&); complex& operator+= (const complex&); complex& operator-= (const complex&); complex& operator*= (const complex& rhs); complex& operator/= (const complex&); complex& operator= (const complex& rhs); complex& operator+= (const complex& rhs); complex& operator-= (const complex& rhs); complex& operator*= (const complex& rhs); complex& operator/= (const complex&); #ifndef _RWSTD_NO_FO_RWARD_SPECIALIZATIONS #ifndef _RWSTD_NO_LONGDOUBLE complex& operator= (const complex&); complex& operator+= (const complex&); complex& operator-= (const complex&); complex& operator*= (const complex&); complex& operator/= (const complex&); #endif #endif #endif complex& operator= (double); complex& operator+= (double); complex& operator-= (double); complex& operator*= (double); complex& operator/= (double); private: double re_, im_; }; #ifndef _RWSTD_NO_LONGDOUBLE #if defined(__DECCXX) && !defined(__DECFIXCXXL508) template <> #endif class _RWSTDExport complex { public: typedef long double value_type; complex (const long double& re_arg=0.0L, const long double& imag_arg=0.0L) { re_=re_arg; im_=imag_arg; } complex (const complex&); complex (const complex&); complex (const complex&); ~complex() { ; } long double imag () const { return im_; } long double real () const { return re_; } #ifndef _RWSTD_NO_MEMBER_TEMPLATES template complex& operator= (const complex& rhs) {re_=rhs.real(); im_=rhs.imag(); return *this;} template complex& operator+= (const complex& rhs) {re_+=rhs.real(); im_+=rhs.imag(); return *this;} template complex& operator-= (const complex& rhs) {re_-=rhs.real(); im_-=rhs.imag(); return *this;} template complex& operator*= (const complex& rhs) {long double tmp=re_*rhs.real()-im_*rhs.imag(); im_=im_*rhs.real()+re_*rhs.imag(); re_=tmp; return *this;} template complex& operator/= (const complex&); #else /* Have to specialize each one :-( */ complex& operator= (const complex&); complex& operator+= (const complex&); complex& operator-= (const complex&); complex& operator*= (const complex&); complex& operator/= (const complex&); complex& operator= (const complex&); complex& operator+= (const complex&); complex& operator-= (const complex&); complex& operator*= (const complex&); complex& operator/= (const complex&); complex& operator= (const complex&); complex& operator+= (const complex&); complex& operator-= (const complex&); complex& operator*= (const complex&); complex& operator/= (const complex&); #endif complex& operator= (long double); complex& operator+= (long double); complex& operator-= (long double); complex& operator*= (long double); complex& operator/= (long double); private: long double re_, im_; }; #endif #ifndef _RWSTD_NO_FO_RWARD_SPECIALIZATIONS template class _RWSTDExportTemplate complex { public: typedef T value_type; complex (const T& re_arg=0, const T& imag_arg=0) { re_=re_arg; im_=imag_arg; } ~complex() { ; } T imag () const { return im_; } T real () const { return re_; } #ifndef _RWSTD_NO_MEMBER_TEMPLATES template complex (const complex& rhs) {re_=rhs.real(); im_=rhs.imag();} template complex& operator= (const complex& rhs) {re_=rhs.real(); im_=rhs.imag(); return *this;} template complex& operator+= (const complex& rhs) {re_+=rhs.real(); im_+=rhs.imag(); return *this;} template complex& operator-= (const complex& rhs) {re_-=rhs.real(); im_-=rhs.imag(); return *this;} template complex& operator*= (const complex& rhs) {T tmp=re_*rhs.real()-im_*rhs.imag(); im_=im_*rhs.real()+re_*rhs.imag(); re_=tmp; return *this;} template complex& operator/= (const complex&); #endif complex& operator= (T); complex& operator+= (T); complex& operator-= (T); complex& operator*= (T); complex& operator/= (T); private: T re_, im_; }; #endif // // Temporarily turn off the warnings under the Borland compiler that // say 'Functions containing ... cannot be inlined' // #if defined(__BORLANDC__) #pragma warn -inl #endif template inline complex& complex::operator= (T rhs) { re_ = rhs; im_ = 0.0; return *this; } template inline complex& complex::operator+= (T rhs) { re_ += rhs; return *this; } template inline complex& complex::operator-= (T rhs) { re_ -= rhs; return *this; } template inline complex& complex::operator*= (T rhs) { T tmp = re_*rhs; im_ = im_*rhs; re_ = tmp; return *this; } template inline complex& complex::operator/= (T rhs) { T denom = rhs*rhs; T re = (re_*rhs)/denom; T im = (rhs*im_)/denom; re_ = re; im_ = im; return *this; } // // complex specializations. // inline complex::complex (const complex& cf) { re_ = cf.real(); im_ = cf.imag(); } #ifndef _RWSTD_NO_FO_RWARD_SPECIALIZATIONS inline complex::complex (const complex& cd) { re_ = _RWSTD_STATIC_CAST(float,cd.real()); im_ = _RWSTD_STATIC_CAST(float,cd.imag()); } #ifndef _RWSTD_NO_LONGDOUBLE inline complex::complex (const complex& cld) { re_ = _RWSTD_STATIC_CAST(float,cld.real()); im_ = _RWSTD_STATIC_CAST(float,cld.imag()); } #endif #endif #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator= (const complex& rhs) { re_ = rhs.real(); im_ = rhs.imag(); return *this; } #endif inline complex& complex::operator= (float rhs) { re_ = rhs; im_ = 0.0; return *this; } #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator+= (const complex& rhs) { re_ += rhs.real(); im_ += rhs.imag(); return *this; } #endif inline complex& complex::operator+= (float rhs) { re_ += rhs; return *this; } #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator-= (const complex& rhs) { re_ -= rhs.real(); im_ -= rhs.imag(); return *this; } #endif inline complex& complex::operator-= (float rhs) { re_ -= rhs; return *this; } #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator*= (const complex& rhs) { float tmp = re_*rhs.real()-im_*rhs.imag(); im_ = im_*rhs.real()+re_*rhs.imag(); re_ = tmp; return *this; } #endif inline complex& complex::operator*= (float rhs) { float tmp = re_*rhs; im_ = im_*rhs; re_ = tmp; return *this; } #ifndef _RWSTD_NO_FO_RWARD_SPECIALIZATIONS #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator= (const complex& rhs) { re_ = _RWSTD_STATIC_CAST(float,rhs.real()); im_ = _RWSTD_STATIC_CAST(float,rhs.imag()); return *this; } inline complex& complex::operator+= (const complex& rhs) { re_ += _RWSTD_STATIC_CAST(float,rhs.real()); im_ += _RWSTD_STATIC_CAST(float,rhs.imag()); return *this; } inline complex& complex::operator-= (const complex& rhs) { re_ -= _RWSTD_STATIC_CAST(float,rhs.real()); im_ -= _RWSTD_STATIC_CAST(float,rhs.imag()); return *this; } inline complex& complex::operator*= (const complex& rhs) { float tmp = re_*_RWSTD_STATIC_CAST(float,rhs.real())- im_*_RWSTD_STATIC_CAST(float,rhs.imag()); im_ = im_*_RWSTD_STATIC_CAST(float,rhs.real())+ re_*_RWSTD_STATIC_CAST(float,rhs.imag()); re_ = tmp; return *this; } #endif #ifndef _RWSTD_NO_LONGDOUBLE #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator= (const complex& rhs) { re_ = _RWSTD_STATIC_CAST(float,rhs.real()); im_ = _RWSTD_STATIC_CAST(float,rhs.imag()); return *this; } inline complex& complex::operator+= (const complex& rhs) { re_ += _RWSTD_STATIC_CAST(float,rhs.real()); im_ += _RWSTD_STATIC_CAST(float,rhs.imag()); return *this; } inline complex& complex::operator-= (const complex& rhs) { re_ -= _RWSTD_STATIC_CAST(float,rhs.real()); im_ -= _RWSTD_STATIC_CAST(float,rhs.imag()); return *this; } inline complex& complex::operator*= (const complex& rhs) { float tmp = re_*_RWSTD_STATIC_CAST(float,rhs.real())- im_*_RWSTD_STATIC_CAST(float,rhs.imag()); im_ = im_*_RWSTD_STATIC_CAST(float,rhs.real())+ re_*_RWSTD_STATIC_CAST(float,rhs.imag()); re_ = tmp; return *this; } #endif #endif #endif // // complex specializations. // inline complex::complex (const complex& cf) : re_(cf.real()), im_(cf.imag()) {} inline complex::complex (const complex& cd) : re_(cd.real()), im_(cd.imag()) {} #ifndef _RWSTD_NO_FO_RWARD_SPECIALIZATIONS #ifndef _RWSTD_NO_LONGDOUBLE inline complex::complex (const complex& cld) : re_(_RWSTD_STATIC_CAST(double,cld.real())), im_(_RWSTD_STATIC_CAST(double,cld.imag())) {} #endif #endif #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator= (const complex& rhs) { re_ = rhs.real(); im_ = rhs.imag(); return *this; } #endif inline complex& complex::operator= (double rhs) { re_ = rhs; im_ = 0.0; return *this; } #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator+= (const complex& rhs) { re_ += rhs.real(); im_ += rhs.imag(); return *this; } #endif inline complex& complex::operator+= (double rhs) { re_ += rhs; return *this; } #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator-= (const complex& rhs) { re_ -= rhs.real(); im_ -= rhs.imag(); return *this; } #endif inline complex& complex::operator-= (double rhs) { re_ -= rhs; return *this; } #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator*= (const complex& rhs) { double tmp = re_*rhs.real()-im_*rhs.imag(); im_ = im_*rhs.real()+re_*rhs.imag(); re_ = tmp; return *this; } #endif #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator= (const complex& rhs) { re_ = rhs.real(); im_ = rhs.imag(); return *this; } inline complex& complex::operator+= (const complex& rhs) { re_ += rhs.real(); im_ += rhs.imag(); return *this; } inline complex& complex::operator-= (const complex& rhs) { re_ -= rhs.real(); im_ -= rhs.imag(); return *this; } inline complex& complex::operator*= (const complex& rhs) { double tmp = re_*rhs.real()-im_*rhs.imag(); im_ = im_*rhs.real()+re_*rhs.imag(); re_ = tmp; return *this; } #endif inline complex& complex::operator*= (double rhs) { double tmp = re_*rhs; im_ = im_*rhs; re_ = tmp; return *this; } #ifndef _RWSTD_NO_FO_RWARD_SPECIALIZATIONS #ifndef _RWSTD_NO_LONGDOUBLE #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator= (const complex& rhs) { re_ = _RWSTD_STATIC_CAST(double,rhs.real()); im_ = _RWSTD_STATIC_CAST(double,rhs.imag()); return *this; } inline complex& complex::operator+= (const complex& rhs) { re_ += _RWSTD_STATIC_CAST(double,rhs.real()); im_ += _RWSTD_STATIC_CAST(double,rhs.imag()); return *this; } inline complex& complex::operator-= (const complex& rhs) { re_ -= _RWSTD_STATIC_CAST(double,rhs.real()); im_ -= _RWSTD_STATIC_CAST(double,rhs.imag()); return *this; } inline complex& complex::operator*= (const complex& rhs) { double tmp = re_*_RWSTD_STATIC_CAST(double,rhs.real())- im_*_RWSTD_STATIC_CAST(double,rhs.imag()); im_ = im_*_RWSTD_STATIC_CAST(double,rhs.real())+ re_*_RWSTD_STATIC_CAST(double,rhs.imag()); re_ = tmp; return *this; } #endif #endif #endif // // complex specializations. // #ifndef _RWSTD_NO_LONGDOUBLE inline complex::complex (const complex& cf) : re_(cf.real()), im_(cf.imag()) {} inline complex::complex (const complex& cd) : re_(cd.real()), im_(cd.imag()) {} inline complex::complex (const complex& cld) : re_(cld.real()), im_(cld.imag()) {} #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator= (const complex& rhs) { re_ = rhs.real(); im_ = rhs.imag(); return *this; } inline complex& complex::operator+= (const complex& rhs) { re_ += rhs.real(); im_ += rhs.imag(); return *this; } #endif inline complex& complex::operator+= (long double rhs) { re_ += rhs; return *this; } #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator-= (const complex& rhs) { re_ -= rhs.real(); im_ -= rhs.imag(); return *this; } inline complex& complex::operator*= (const complex& rhs) { long double tmp = re_*rhs.real()-im_*rhs.imag(); im_ = im_*rhs.real()+re_*rhs.imag(); re_ = tmp; return *this; } inline complex& complex::operator= (const complex& rhs) { re_ = rhs.real(); im_ = rhs.imag(); return *this; } #endif inline complex& complex::operator= (long double rhs) { re_ = rhs; im_ = 0.0; return *this; } #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator+= (const complex& rhs) { re_ += rhs.real(); im_ += rhs.imag(); return *this; } inline complex& complex::operator-= (const complex& rhs) { re_ -= rhs.real(); im_ -= rhs.imag(); return *this; } #endif inline complex& complex::operator-= (long double rhs) { re_ -= rhs; return *this; } #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator*= (const complex& rhs) { long double tmp = re_*rhs.real()-im_*rhs.imag(); im_ = im_*rhs.real()+re_*rhs.imag(); re_ = tmp; return *this; } #endif inline complex& complex::operator*= (long double rhs) { long double tmp = re_*rhs; im_ = im_*rhs; re_ = tmp; return *this; } #if defined(__DECCXX) && !defined(__DECFIXCXXL440) && defined(_RWSTD_NO_MEMBER_TEMPLATES) inline complex& complex::operator= (const complex& rhs) { re_ = rhs.real(); im_ = rhs.imag(); return *this; } inline complex& complex::operator+= (const complex& rhs) { re_ += rhs.real(); im_ += rhs.imag(); return *this; } inline complex& complex::operator-= (const complex& rhs) { re_ -= rhs.real(); im_ -= rhs.imag(); return *this; } inline complex& complex::operator*= (const complex& rhs) { long double tmp = re_*rhs.real()-im_*rhs.imag(); im_ = im_*rhs.real()+re_*rhs.imag(); re_ = tmp; return *this; } #endif #endif #ifndef _RWSTD_NO_MEMBER_TEMPLATES template template complex& complex::operator/= (const complex& rhs) { T denom = rhs.real()*rhs.real() + rhs.imag()*rhs.imag(); T re = (re_*rhs.real()+im_*rhs.imag())/denom; T im = (rhs.real()*im_-re_*rhs.imag())/denom; re_ = re; im_ = im; return *this; } template complex& complex::operator/= (const complex& rhs) { float denom = rhs.real()*rhs.real() + rhs.imag()*rhs.imag(); float re = (re_*rhs.real()+im_*rhs.imag())/denom; float im = (rhs.real()*im_-re_*rhs.imag())/denom; re_ = re; im_ = im; return *this; } template complex& complex::operator/= (const complex& rhs) { double denom = rhs.real()*rhs.real() + rhs.imag()*rhs.imag(); double re = (re_*rhs.real()+im_*rhs.imag())/denom; double im = (rhs.real()*im_-re_*rhs.imag())/denom; re_ = re; im_ = im; return *this; } #ifndef _RWSTD_NO_LONGDOUBLE template complex& complex::operator/= (const complex& rhs) { long double denom = rhs.real()*rhs.real() + rhs.imag()*rhs.imag(); long double re = (re_*rhs.real()+im_*rhs.imag())/denom; long double im = (rhs.real()*im_-re_*rhs.imag())/denom; re_ = re; im_ = im; return *this; } #endif #else /* No member function templates, have to specialize :-( */ inline complex& complex::operator/= (const complex& rhs) { float denom = rhs.real()*rhs.real() + rhs.imag()*rhs.imag(); float re = (re_*rhs.real()+im_*rhs.imag())/denom; float im = (rhs.real()*im_-re_*rhs.imag())/denom; re_ = re; im_ = im; return *this; } #ifndef _RWSTD_NO_FO_RWARD_SPECIALIZATIONS inline complex& complex::operator/= (const complex& rhs) { float denom = _RWSTD_STATIC_CAST(float,rhs.real())* _RWSTD_STATIC_CAST(float,rhs.real()) + _RWSTD_STATIC_CAST(float,rhs.imag())* _RWSTD_STATIC_CAST(float,rhs.imag()); float re = (re_*_RWSTD_STATIC_CAST(float,rhs.real())+ im_*_RWSTD_STATIC_CAST(float,rhs.imag()))/denom; float im = (_RWSTD_STATIC_CAST(float,rhs.real())*im_-re_* _RWSTD_STATIC_CAST(float,rhs.imag()))/denom; re_ = re; im_ = im; return *this; } #ifndef _RWSTD_NO_LONGDOUBLE inline complex& complex::operator/= (const complex& rhs) { float denom = _RWSTD_STATIC_CAST(float,rhs.real())* _RWSTD_STATIC_CAST(float,rhs.real()) + _RWSTD_STATIC_CAST(float,rhs.imag())* _RWSTD_STATIC_CAST(float,rhs.imag()); float re = (re_*_RWSTD_STATIC_CAST(float,rhs.real())+ im_*_RWSTD_STATIC_CAST(float,rhs.imag()))/denom; float im = (_RWSTD_STATIC_CAST(float,rhs.real())*im_- re_*_RWSTD_STATIC_CAST(float,rhs.imag()))/denom; re_ = re; im_ = im; return *this; } #endif #endif inline complex& complex::operator/= (const complex& rhs) { double denom = rhs.real()*rhs.real() + rhs.imag()*rhs.imag(); double re = (re_*rhs.real()+im_*rhs.imag())/denom; double im = (rhs.real()*im_-re_*rhs.imag())/denom; re_ = re; im_ = im; return *this; } inline complex& complex::operator/= (const complex& rhs) { double denom = rhs.real()*rhs.real() + rhs.imag()*rhs.imag(); double re = (re_*rhs.real()+im_*rhs.imag())/denom; double im = (rhs.real()*im_-re_*rhs.imag())/denom; re_ = re; im_ = im; return *this; } #ifndef _RWSTD_NO_FO_RWARD_SPECIALIZATIONS #ifndef _RWSTD_NO_LONGDOUBLE inline complex& complex::operator/= (const complex& rhs) { double denom = _RWSTD_STATIC_CAST(double,rhs.real())* _RWSTD_STATIC_CAST(double,rhs.real()) + _RWSTD_STATIC_CAST(double,rhs.imag())* _RWSTD_STATIC_CAST(double,rhs.imag()); double re = (re_*_RWSTD_STATIC_CAST(double,rhs.real())+ im_*_RWSTD_STATIC_CAST(double,rhs.imag()))/denom; double im = (_RWSTD_STATIC_CAST(double,rhs.real())*im_- re_*_RWSTD_STATIC_CAST(double,rhs.imag()))/denom; re_ = re; im_ = im; return *this; } #endif #endif #ifndef _RWSTD_NO_LONGDOUBLE inline complex& complex::operator/= (const complex& rhs) { long double denom = rhs.real()*rhs.real() + rhs.imag()*rhs.imag(); long double re = (re_*rhs.real()+im_*rhs.imag())/denom; long double im = (rhs.real()*im_-re_*rhs.imag())/denom; re_ = re; im_ = im; return *this; } inline complex& complex::operator/= (const complex& rhs) { long double denom = rhs.real()*rhs.real() + rhs.imag()*rhs.imag(); long double re = (re_*rhs.real()+im_*rhs.imag())/denom; long double im = (rhs.real()*im_-re_*rhs.imag())/denom; re_ = re; im_ = im; return *this; } inline complex& complex::operator/= (const complex& rhs) { long double denom = rhs.real()*rhs.real() + rhs.imag()*rhs.imag(); long double re = (re_*rhs.real()+im_*rhs.imag())/denom; long double im = (rhs.real()*im_-re_*rhs.imag())/denom; re_ = re; im_ = im; return *this; } #endif #endif inline complex& complex::operator/= (float rhs) { float denom = rhs*rhs; float re = (re_*rhs)/denom; float im = (rhs*im_)/denom; re_ = re; im_ = im; return *this; } inline complex& complex::operator/= (double rhs) { double denom = rhs*rhs; double re = (re_*rhs)/denom; double im = (rhs*im_)/denom; re_ = re; im_ = im; return *this; } inline complex& complex::operator/= (long double rhs) { long double denom = rhs*rhs; long double re = (re_*rhs)/denom; long double im = (rhs*im_)/denom; re_ = re; im_ = im; return *this; } // // complex non-member operations // template inline complex operator+ (const complex& lhs, const complex& rhs) { complex tmp = lhs; return tmp += rhs; } template inline complex operator+ (const complex& lhs, const T& rhs) { return complex(rhs+lhs.real(), lhs.imag()); } template inline complex operator+ (const T& lhs, const complex& rhs) { return complex(lhs+rhs.real(), rhs.imag()); } template inline complex operator- (const complex& lhs, const complex& rhs) { complex tmp = lhs; return tmp -= rhs; } template inline complex operator- (const complex& lhs, const T& rhs) { return complex(lhs.real()-rhs, lhs.imag()); } template inline complex operator- (const T& lhs, const complex& rhs) { return complex(lhs-rhs.real(), -rhs.imag()); } template inline complex operator* (const complex& lhs, const complex& rhs) { complex tmp = lhs; return tmp *= rhs; } template inline complex operator* (const complex& lhs, const T& rhs) { return complex(rhs*lhs.real(), rhs*lhs.imag()); } template inline complex operator* (const T& lhs, const complex& rhs) { return complex(lhs*rhs.real(), lhs*rhs.imag()); } template inline complex operator/ (const complex& lhs, const complex& rhs) { complex tmp = lhs; return tmp /= rhs; } template inline complex operator/ (const complex& lhs, const T& rhs) { return complex(lhs.real()/rhs, lhs.imag()/rhs); } template inline complex operator/ (const T& lhs, const complex& rhs) { register T denom = rhs.real()*rhs.real() + rhs.imag()*rhs.imag(); return complex(lhs*rhs.real()/denom,(-lhs*rhs.imag())/denom); } template inline complex operator+ (const complex& lhs) { return lhs; } template inline complex operator- (const complex& lhs) { return complex(-lhs.real(), -lhs.imag()); } template inline bool operator== (const complex& lhs, const complex& rhs) { return lhs.real() == rhs.real() && lhs.imag() == rhs.imag(); } template inline bool operator== (const T& lhs, const complex& rhs) { return lhs == rhs.real() && rhs.imag() == 0; } template inline bool operator== (const complex& lhs, const T& rhs) { return lhs.real() == rhs && lhs.imag() == 0; } #ifndef _RWSTD_NO_NAMESPACE template inline bool operator!= (const complex& lhs, const complex& rhs) { return lhs.real() != rhs.real() || lhs.imag() != rhs.imag(); } #endif template inline bool operator!= (const T& lhs, const complex& rhs) { return lhs != rhs.real() || rhs.imag() != 0; } template inline bool operator!= (const complex& lhs, const T& rhs) { return lhs.real() != rhs || lhs.imag() != 0; } // // complex value operations // // Cope with namespace problems #if defined(_RWSTD_NO_NEW_HEADER) && !defined(_RWSTD_NO_NAMESPACE) #define _RWSTD_C_SCOPE_SIN ::sin #define _RWSTD_C_SCOPE_SINH ::sinh #define _RWSTD_C_SCOPE_COS ::cos #define _RWSTD_C_SCOPE_COSH ::cosh #define _RWSTD_C_SCOPE_ATAN2 ::atan2 #define _RWSTD_C_SCOPE_ATAN ::atan #define _RWSTD_C_SCOPE_EXP ::exp #define _RWSTD_C_SCOPE_POW ::pow #define _RWSTD_C_SCOPE_SQRT ::sqrt #define _RWSTD_C_SCOPE_LOG ::log #define _RWSTD_C_SCOPE_LOG10 ::log10 #else #define _RWSTD_C_SCOPE_SIN sin #define _RWSTD_C_SCOPE_SINH sinh #define _RWSTD_C_SCOPE_COS cos #define _RWSTD_C_SCOPE_COSH cosh #define _RWSTD_C_SCOPE_ATAN2 atan2 #define _RWSTD_C_SCOPE_ATAN atan #define _RWSTD_C_SCOPE_EXP exp #define _RWSTD_C_SCOPE_POW pow #define _RWSTD_C_SCOPE_SQRT sqrt #define _RWSTD_C_SCOPE_LOG log #define _RWSTD_C_SCOPE_LOG10 log10 #endif template inline T real (const complex& a) { return a.real(); } template inline T imag (const complex& a) { return a.imag(); } template inline T norm (const complex& a) { return a.real()*a.real() + a.imag()*a.imag(); } template inline T abs (const complex& a) { return (_RWSTD_C_SCOPE_SQRT(norm(a))); } // // We guarantee that arg(complex(0,0)) == 0. // template inline T arg (const complex& a) { return a == complex(0,0) ? T(0) : _RWSTD_C_SCOPE_ATAN2(a.imag(), a.real()); } template complex conj (const complex& a) { return complex(a.real(), -a.imag()); } #if _MSC_VER < 901 // // A very bizarre Microsoft problem. // inline complex conj (const complex& a) { return complex(a.real(), -a.imag()); } inline complex conj (const complex& a) { return complex(a.real(), -a.imag()); } #ifndef _RWSTD_NO_LONGDOUBLE inline complex conj (const complex& a) { return complex(a.real(), -a.imag()); } #endif #endif template #ifndef _RWSTD_NO_INIT_CONST_TEMPLATE_REF_ARG inline complex polar (T r, const T& theta = 0) #else inline complex polar (T r, const T& theta) #endif { return complex(r*_RWSTD_C_SCOPE_COS(theta), r*_RWSTD_C_SCOPE_SIN(theta)); } // // transcendentals // // // complex cosine of complex number a // cos (a) = cos u * cosh v - i * sin u * sinh v // template inline complex cos (const complex& a) { return complex(_RWSTD_C_SCOPE_COS(a.real())*_RWSTD_C_SCOPE_COSH(a.imag()), -_RWSTD_C_SCOPE_SIN(a.real())*_RWSTD_C_SCOPE_SINH(a.imag())); } // // complex hyperbolic cosine of complex number a // cosh (a) = cosh u * cosv + i * sinh u * sin v // template inline complex cosh (const complex& a) { return complex(_RWSTD_C_SCOPE_COSH(a.real())*_RWSTD_C_SCOPE_COS(a.imag()), _RWSTD_C_SCOPE_SINH(a.real())*_RWSTD_C_SCOPE_SIN(a.imag())); } // // complex exponential of complex number a // exp (a) = exp(u) * (cos v + i * sin v) // template inline complex exp (const complex& a) { register T e = _RWSTD_C_SCOPE_EXP(a.real()); return complex(e*_RWSTD_C_SCOPE_COS(a.imag()), e*_RWSTD_C_SCOPE_SIN(a.imag())); } // // complex natural log of complex number a // log(a) = log(r) + i * theta // template inline complex log (const complex& a) { return complex(_RWSTD_C_SCOPE_LOG(abs(a)), arg(a)); } template complex log10 (const complex& a) { #if defined(__DECCXX) && !defined(__DECFIXCXXL397) const T log10e = _RWSTD_C_SCOPE_LOG10(_RWSTD_C_SCOPE_EXP(T(1))); #else static const T log10e = _RWSTD_C_SCOPE_LOG10(_RWSTD_C_SCOPE_EXP(T(1))); #endif return log10e * log(a); } // // For all the power functions: // // 0**0 == 1 // 0**x == 0 for x != 0 // // // complex number a raised to an integer power n // // a**n = r**n * (cos(n theta) + i sin (n theta)) // template complex pow (const complex& a, int n) { if (a == complex(0,0)) { if (n == 0) return complex(1,0); else return complex(0,0); } if (a.imag() == 0) { if (a.real() < 0) return pow(a, complex(n,0)); else return complex(_RWSTD_C_SCOPE_POW(a.real(),T(n)), 0); } register T r = _RWSTD_C_SCOPE_POW(T(abs(a)), T(n)); register T th = T(n) * arg(a); return complex(r*_RWSTD_C_SCOPE_COS(th), r*_RWSTD_C_SCOPE_SIN(th)); } // // complex number a raised to a real power s // // a**s = exp(s * log(a)) // template complex pow (const complex& a, T s) { if (a == complex(0,0)) { if (s == T(0)) return complex(1,0); else return complex(0,0); } if (a.imag() == 0) { if (a.real() < 0) return pow(a, complex(s,0)); else return complex(_RWSTD_C_SCOPE_POW(a.real(),s), 0); } return exp(s*log(a)); } // // real number s raised to a complex power a // // s**a = exp(a * log (s)) // template complex pow (T s, const complex& a) { if (s == T(0)) { if (a == complex(0,0)) return complex(1,0); else return complex(0,0); } if (s < 0) return pow(complex(s,0), a); if (a.imag() == 0) return complex(_RWSTD_C_SCOPE_POW(s, a.real()), 0); return complex(exp(a * (T) _RWSTD_C_SCOPE_LOG(s))); } // // complex number a1 raised to a complex power a2 // // a1**a2 = rho * (cos(phi) + i sin(phi)) // rho = r1 **u2 * exp (-v2* theta1) // phi = v2 * log(r1) + u2 * theta1 // template complex pow (const complex& a1, const complex& a2) { if (a1 == complex(0,0)) { if (a2 == complex(0,0)) return complex(1,0); else return complex(0,0); } T r1 = abs(a1); T u2 = real(a2); T v2 = imag(a2); T th1 = arg(a1); T rho = _RWSTD_C_SCOPE_POW(r1, u2) * _RWSTD_C_SCOPE_EXP(-v2 * th1); T phi = v2 * _RWSTD_C_SCOPE_LOG(r1) + u2 * th1; return complex(rho*_RWSTD_C_SCOPE_COS(phi), rho*_RWSTD_C_SCOPE_SIN(phi)); } // // complex sine of complex number a // sin (a) = sin u * cosh v + i * cos u * sinh v // template inline complex sin (const complex& a) { return complex(_RWSTD_C_SCOPE_SIN(a.real())*_RWSTD_C_SCOPE_COSH(a.imag()), _RWSTD_C_SCOPE_COS(a.real())*_RWSTD_C_SCOPE_SINH(a.imag())); } // // complex hyperbolic sine of complex number a // sinh (a) = sinh u cos v + i cosh u sin v // template inline complex sinh (const complex& a) { return complex(_RWSTD_C_SCOPE_SINH(a.real())*_RWSTD_C_SCOPE_COS(a.imag()), _RWSTD_C_SCOPE_COSH(a.real())*_RWSTD_C_SCOPE_SIN(a.imag())); } // // complex square root of complex number a // sqrt(a) = sqrt(r) * ( cos (theta/2) + i sin (theta/2) ) // template inline complex sqrt (const complex& a) { register T r = _RWSTD_C_SCOPE_SQRT(abs(a)); register T th = arg(a)/2.; return complex(r*_RWSTD_C_SCOPE_COS(th), r*_RWSTD_C_SCOPE_SIN(th)); } template inline complex tan (const complex& a) { return sin(a)/cos(a); } template inline complex tanh (const complex& a) { return sinh(a)/cosh(a); } #ifdef __USE_STD_IOSTREAM template basic_istream& _RWSTDExportTemplate operator>> (basic_istream& is,complex& x); template basic_ostream& _RWSTDExportTemplate operator<< (basic_ostream& os,const complex& x); #else template istream& _RWSTDExportTemplate operator>> (istream& is, complex& x); template ostream& _RWSTDExportTemplate operator<< (ostream& os, const complex& x); #endif #ifndef _RWSTD_NO_NAMESPACE } #endif #if defined(_RWSTD_NO_DESTROY_BUILTIN) || defined(_RWSTD_NO_DESTROY_NONBUILTIN) #ifndef _RWSTD_NO_NAMESPACE namespace __rogue_wave_std { #endif // // Specializations of STL destroy for complex. // inline void __destroy (complex**) {} inline void __destroy (complex***) {} inline void __destroy (complex****) {} inline void __destroy (complex**) {} inline void __destroy (complex***) {} inline void __destroy (complex****) {} #ifndef _RWSTD_NO_LONGDOUBLE inline void __destroy (complex**) {} inline void __destroy (complex***) {} inline void __destroy (complex****) {} #endif #ifndef _RWSTD_NO_NAMESPACE } #endif #endif #ifdef _RWSTD_COMPILE_INSTANTIATE #include #endif #if defined(__DECCXX) # ifdef __PRAGMA_ENVIRONMENT # pragma __environment __restore # endif #endif #endif /* __STD_COMPLEX */