xue@11: /*
xue@11:     Harmonic sinusoidal modelling and tools
xue@11: 
xue@11:     C++ code package for harmonic sinusoidal modelling and relevant signal processing.
xue@11:     Centre for Digital Music, Queen Mary, University of London.
xue@11:     This file copyright 2011 Wen Xue.
xue@11: 
xue@11:     This program is free software; you can redistribute it and/or
xue@11:     modify it under the terms of the GNU General Public License as
xue@11:     published by the Free Software Foundation; either version 2 of the
xue@11:     License, or (at your option) any later version.
xue@11: */
xue@1: #ifndef XCOMPLEX
xue@1: #define XCOMPLEX
xue@1: 
xue@1: 
Chris@5: #include <math.h>
Chris@5: 
Chris@5: /**
Chris@5:   \file xcomplex.h - Xue's complex number class.
xue@1: 
xue@1:   This classes is modelled after standard c++ complex class, with a few additional methods. Unused
xue@1:   standard member and non-member functions/operators may not have been implemented.
xue@1: */
xue@1: 
xue@1: template <class T> class cmplx
xue@1: {
xue@1: public:
xue@1: //standard members
xue@1:   T x;
xue@1:   T y;
xue@1:   cmplx(){}
xue@1:   cmplx(const T& c, const T& d) {x=c; y=d;}
xue@1: 	cmplx(const T& c) {x=c; y=0;}
xue@1:   template<class X> cmplx(const cmplx<X>& c){x=c.x, y=c.y;}
xue@1: 
xue@1:   T real(){return x;}
xue@1:   T imag(){return y;}
xue@1: 
xue@1:   cmplx<T>& operator=(const T& c){x=c; y=0; return *this;}
xue@10:   template<class X> cmplx<T>& operator+=(const X& c){x+=c; return *this;}
xue@10:   template<class X> cmplx<T>& operator-=(const X& c){x-=c; return *this;}
xue@1:   template<class X> cmplx<T>& operator*=(const X& c){x*=c; y*=c; return *this;}
xue@1:   template<class X> cmplx<T>& operator/=(const X& c){x/=c; y/=c; return *this;}
xue@1:   template<class X> cmplx<T>& operator=(const cmplx<X>& c){x=c.x; y=c.y; return* this;}
xue@1: 
xue@1:   template<class X> cmplx<T>& operator+=(const cmplx<X>& c){x+=c.x; y+=c.y; return *this;}
xue@1:   template<class X> cmplx<T>& operator-=(const cmplx<X>& c){x-=c.x; y-=c.y; return *this;}
xue@1:   template<class X> cmplx<T>& operator*=(const cmplx<X>& c){T tmpx=x*c.x-y*c.y; y=x*c.y+y*c.x; x=tmpx; return *this;}
xue@1:   template<class X> cmplx<T>& operator/=(const cmplx<X>& c){if (c.y==0){x/=c.x; y/=c.x;} else if (c.x==0){T tmpx=y/c.y; y=-x/c.y; x=tmpx;} else {T xm=c.x*c.x+c.y*c.y; T tmpx=(c.x*x+c.y*y)/xm; y=(y*c.x-x*c.y)/xm; x=tmpx;} return *this;}
xue@1: 
xue@1: //non-standard members
xue@1:   //operator~: square of absolute value
xue@1:   T operator~() {return x*x+y*y;}
xue@1:   //operator*: complex conjugate
xue@1:   cmplx<T> operator*(){cmplx<T> result; result.x=x; result.y=-y; return result;}
xue@1:   //operator^: multiplicaiton with the complex conjugate of the argument
xue@1:   cmplx<T> operator^(const cmplx &b){cmplx<T> result; result.x=x*b.x+y*b.y; result.y=y*b.x-x*b.y; return result;}
xue@1:   //cinv: complex reciprocal
xue@1:   cmplx<T> cinv(){cmplx<T> result; if (y==0) result.x=1/x, result.y=0; else if (x==0) result.y=-1/y, result.x=0; else{T xm=x*x+y*y; result.x=x/xm; result.y=-y/xm;} return result;}
xue@1:   //rotate: rotate by an angle
xue@1:   cmplx<T>& rotate(const T ph) {double s=sin(ph), c=cos(ph), tmpx; tmpx=x*c-y*s; y=x*s+y*c; x=tmpx; return *this;}
xue@1: };  //*/
xue@1: //standard Non-member Operators
xue@1: template<class Ta, class Tb> cmplx<Ta> operator+(const cmplx<Ta>& a, const cmplx<Tb>& b){cmplx<Ta> result=a; result+=b; return result;}
xue@1: template<class Ta, class Tb> cmplx<Ta> operator+(const cmplx<Ta>& a, Tb& b){cmplx<Ta> result=a; result+=b; return result;}
xue@1: template<class T> cmplx<T> operator+(T a, const cmplx<T>& b){cmplx<T> result=a; result+=b; return result;}
xue@1: template<class Ta, class Tb> cmplx<Ta> operator-(const cmplx<Ta>& a, const cmplx<Tb>& b){cmplx<Ta> result=a; result-=b; return result;}
xue@1: template<class Ta, class Tb> cmplx<Ta> operator-(const cmplx<Ta>& a, Tb& b){cmplx<Ta> result=a; result-=b; return result;}
xue@1: template<class T> cmplx<T> operator-(T a, const cmplx<T>& b){cmplx<T> result=a; result-=b; return result;}
xue@1: template<class Ta, class Tb> cmplx<Ta> operator*(const cmplx<Ta>& a, const cmplx<Tb>& b){cmplx<Ta> result=a; result*=b; return result;}
xue@1: template<class Ta, class Tb> cmplx<Ta> operator*(const cmplx<Ta>& a, Tb& b){cmplx<Ta> result=a; result*=b; return result;}
xue@1: template<class T> cmplx<T> operator*(T& a, const cmplx<T>& b){cmplx<T> result=b; result*=a; return result;}
xue@1: template<class Ta, class Tb> cmplx<Ta> operator/(const cmplx<Ta>& a, const cmplx<Tb>& b){cmplx<Ta> result=a; result/=b; return result;}
xue@1: template<class Ta, class Tb> cmplx<Ta> operator/(const cmplx<Ta>& a, Tb& b){cmplx<Ta> result=a; result/=b; return result;}
xue@1: template<class T> cmplx<T> operator/(T a, const cmplx<T>& b){cmplx<T> result=a; result/=b; return result;}
xue@1: template<class T> cmplx<T> operator+(const cmplx<T>& a){return a;}
xue@1: template<class T> cmplx<T> operator-(const cmplx<T>& a){cmplx<T> result; result.x=-a.x; result.y=-a.y; return result;}
xue@1: template<class Ta, class Tb> bool operator==(const cmplx<Ta>& a, const cmplx<Tb>& b){return (a.x==b.x && a.y==b.y);}
xue@1: template<class Ta, class Tb> bool operator==(const cmplx<Ta>& a, Tb b){return (a.x==b && a.y==0);}
xue@1: template<class Ta, class Tb> bool operator==(Ta a, const cmplx<Tb>& b){return (a==b.x && 0==b.y);}
xue@1: template<class Ta, class Tb> bool operator!=(const cmplx<Ta>& a, const cmplx<Tb>& b){return (a.x!=b.x || a.y!=b.y);}
xue@1: template<class Ta, class Tb> bool operator!=(const cmplx<Ta>& a, Tb b){return (a.x!=b || a.y!=0);}
xue@1: template<class Ta, class Tb> bool operator!=(Ta a, const cmplx<Tb>& b){return (a!=b.x || 0!=b.y);}
xue@1: /*
xue@1: template <class T, class charT, class traits> basic_istream<charT, traits>& operator>>(istream&, complex<T>&);
xue@1: template <class T, class charT, class traits> basic_ostream<charT, traits>& operator<<(ostream&, const complex<T>&);
xue@1: */
xue@1: //Values
xue@1: template<class T> T real(const cmplx<T>& a){return a.x;}
xue@1: template<class T> T imag(const cmplx<T>& a){return a.y;}
xue@1: template<class T> T abs(const cmplx<T>& a){return sqrt(a.x*a.x+a.y*a.y);}
xue@1: template<class T> T fabs(const cmplx<T>& a){return sqrt(a.x*a.x+a.y*a.y);}
xue@1: template<class T> T arg(const cmplx<T>& a){return (a.x==0 && a.y==0)?0:atan2(a.y, a.x);}
xue@1: template<class T> T norm(const cmplx<T>& a){return a.x*a.x+a.y*a.y;}
xue@1: template<class T> cmplx<T> conj(const cmplx<T>& a){cmplx<T> result; result.x=a.x; result.y=-a.y; return result;}
xue@1: template<class T> cmplx<T> polar(const T& r, const T& theta){cmplx<T> result; result.x=r*cos(theta); result.y=r*sin(theta); return result;}
xue@1: //Transcendentals
xue@1: /*
xue@1: template<class T> cmplx<T> cos (const cmplx<T>&);
xue@1: template<class T> cmplx<T> cosh (const cmplx<T>&);
xue@1: */
xue@1: template<class T> cmplx<T> exp(const cmplx<T>& a){return polar(exp(a.x), a.y);}
xue@1: template<class T> cmplx<T> log(const cmplx<T>& a){cmplx<T> result; result.x=0.5*log(norm(a)); result.y=arg(a); return result;}
xue@1: /*
xue@1: template<class T> cmplx<T> log10 (const cmplx<T>&);
xue@1: template<class T> cmplx<T> pow (const cmplx<T>&, int);
xue@1: */
xue@1: template<class T> cmplx<T> pow(const cmplx<T>& a, T& e){cmplx<T> result; T rad=abs(a); T angle=arg(a); return polar(rad, angle*e);}
xue@1: /*
xue@1: template<class T> cmplx<T> pow (const cmplx<T>&, const cmplx<T>&);
xue@1: template<class T> cmplx<T> pow (const T&, const cmplx<T>&);
xue@1: template<class T> cmplx<T> sin (const cmplx<T>&);
xue@1: template<class T> cmplx<T> sinh (const cmplx<T>&);
xue@1: */
xue@1: template<class T> cmplx<T> sqrt(const cmplx<T>& a){cmplx<T> result; if (a.y==0) {if (a.x>=0){result.x=sqrt(a.x); result.y=0;} else{result.y=sqrt(-a.x); result.x=0;}} else {result.y=sqrt((sqrt(a.x*a.x+a.y*a.y)-a.x)*0.5); result.x=0.5*a.y/result.y;} return result;}
xue@1: /*
xue@1: template<class T> cmplx<T> tan (const cmplx<T>&);
xue@1: template<class T> cmplx<T> tanh (const cmplx<T>&);
xue@1: */
xue@1: 
xue@1: //non-standard non-member functions
xue@1: //template operator^: multiplying one complex number with the complex conjugate of another
xue@1: template<class T> cmplx<T> operator^(const cmplx<T>& a, const cmplx<T>& b){cmplx<T> result=a; result^=b; return result;}
xue@1: 
xue@1: typedef cmplx<double> cdouble;
xue@1: typedef cmplx<float> cfloat;
xue@1: 
xue@1: #endif