xcomplex.h

Go to the documentation of this file.

/*
    Harmonic sinusoidal modelling and tools

    C++ code package for harmonic sinusoidal modelling and relevant signal processing.
    Centre for Digital Music, Queen Mary, University of London.
    This file copyright 2011 Wen Xue.

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.
*/
#ifndef XCOMPLEX
#define XCOMPLEX


#include <math.h>

template <class T> class cmplx
{
public:
//standard members
  T x;
  T y;
  cmplx(){}
  cmplx(const T& c, const T& d) {x=c; y=d;}
        cmplx(const T& c) {x=c; y=0;}
  template<class X> cmplx(const cmplx<X>& c){x=c.x, y=c.y;}

  T real(){return x;}
  T imag(){return y;}

  cmplx<T>& operator=(const T& c){x=c; y=0; return *this;}
  template<class X> cmplx<T>& operator+=(const X& c){x+=c; return *this;}
  template<class X> cmplx<T>& operator-=(const X& c){x-=c; return *this;}
  template<class X> cmplx<T>& operator*=(const X& c){x*=c; y*=c; return *this;}
  template<class X> cmplx<T>& operator/=(const X& c){x/=c; y/=c; return *this;}
  template<class X> cmplx<T>& operator=(const cmplx<X>& c){x=c.x; y=c.y; return* this;}

  template<class X> cmplx<T>& operator+=(const cmplx<X>& c){x+=c.x; y+=c.y; return *this;}
  template<class X> cmplx<T>& operator-=(const cmplx<X>& c){x-=c.x; y-=c.y; return *this;}
  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;}
  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;}

//non-standard members
  //operator~: square of absolute value
  T operator~() {return x*x+y*y;}
  //operator*: complex conjugate
  cmplx<T> operator*(){cmplx<T> result; result.x=x; result.y=-y; return result;}
  //operator^: multiplicaiton with the complex conjugate of the argument
  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;}
  //cinv: complex reciprocal
  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;}
  //rotate: rotate by an angle
  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;}
};  //*/
//standard Non-member Operators
template<class Ta, class Tb> cmplx<Ta> operator+(const cmplx<Ta>& a, const cmplx<Tb>& b){cmplx<Ta> result=a; result+=b; return result;}
template<class Ta, class Tb> cmplx<Ta> operator+(const cmplx<Ta>& a, Tb& b){cmplx<Ta> result=a; result+=b; return result;}
template<class T> cmplx<T> operator+(T a, const cmplx<T>& b){cmplx<T> result=a; result+=b; return result;}
template<class Ta, class Tb> cmplx<Ta> operator-(const cmplx<Ta>& a, const cmplx<Tb>& b){cmplx<Ta> result=a; result-=b; return result;}
template<class Ta, class Tb> cmplx<Ta> operator-(const cmplx<Ta>& a, Tb& b){cmplx<Ta> result=a; result-=b; return result;}
template<class T> cmplx<T> operator-(T a, const cmplx<T>& b){cmplx<T> result=a; result-=b; return result;}
template<class Ta, class Tb> cmplx<Ta> operator*(const cmplx<Ta>& a, const cmplx<Tb>& b){cmplx<Ta> result=a; result*=b; return result;}
template<class Ta, class Tb> cmplx<Ta> operator*(const cmplx<Ta>& a, Tb& b){cmplx<Ta> result=a; result*=b; return result;}
template<class T> cmplx<T> operator*(T& a, const cmplx<T>& b){cmplx<T> result=b; result*=a; return result;}
template<class Ta, class Tb> cmplx<Ta> operator/(const cmplx<Ta>& a, const cmplx<Tb>& b){cmplx<Ta> result=a; result/=b; return result;}
template<class Ta, class Tb> cmplx<Ta> operator/(const cmplx<Ta>& a, Tb& b){cmplx<Ta> result=a; result/=b; return result;}
template<class T> cmplx<T> operator/(T a, const cmplx<T>& b){cmplx<T> result=a; result/=b; return result;}
template<class T> cmplx<T> operator+(const cmplx<T>& a){return a;}
template<class T> cmplx<T> operator-(const cmplx<T>& a){cmplx<T> result; result.x=-a.x; result.y=-a.y; return result;}
template<class Ta, class Tb> bool operator==(const cmplx<Ta>& a, const cmplx<Tb>& b){return (a.x==b.x && a.y==b.y);}
template<class Ta, class Tb> bool operator==(const cmplx<Ta>& a, Tb b){return (a.x==b && a.y==0);}
template<class Ta, class Tb> bool operator==(Ta a, const cmplx<Tb>& b){return (a==b.x && 0==b.y);}
template<class Ta, class Tb> bool operator!=(const cmplx<Ta>& a, const cmplx<Tb>& b){return (a.x!=b.x || a.y!=b.y);}
template<class Ta, class Tb> bool operator!=(const cmplx<Ta>& a, Tb b){return (a.x!=b || a.y!=0);}
template<class Ta, class Tb> bool operator!=(Ta a, const cmplx<Tb>& b){return (a!=b.x || 0!=b.y);}
/*
template <class T, class charT, class traits> basic_istream<charT, traits>& operator>>(istream&, complex<T>&);
template <class T, class charT, class traits> basic_ostream<charT, traits>& operator<<(ostream&, const complex<T>&);
*/
//Values
template<class T> T real(const cmplx<T>& a){return a.x;}
template<class T> T imag(const cmplx<T>& a){return a.y;}
template<class T> T abs(const cmplx<T>& a){return sqrt(a.x*a.x+a.y*a.y);}
template<class T> T fabs(const cmplx<T>& a){return sqrt(a.x*a.x+a.y*a.y);}
template<class T> T arg(const cmplx<T>& a){return (a.x==0 && a.y==0)?0:atan2(a.y, a.x);}
template<class T> T norm(const cmplx<T>& a){return a.x*a.x+a.y*a.y;}
template<class T> cmplx<T> conj(const cmplx<T>& a){cmplx<T> result; result.x=a.x; result.y=-a.y; return result;}
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;}
//Transcendentals
/*
template<class T> cmplx<T> cos (const cmplx<T>&);
template<class T> cmplx<T> cosh (const cmplx<T>&);
*/
template<class T> cmplx<T> exp(const cmplx<T>& a){return polar(exp(a.x), a.y);}
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;}
/*
template<class T> cmplx<T> log10 (const cmplx<T>&);
template<class T> cmplx<T> pow (const cmplx<T>&, int);
*/
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);}
/*
template<class T> cmplx<T> pow (const cmplx<T>&, const cmplx<T>&);
template<class T> cmplx<T> pow (const T&, const cmplx<T>&);
template<class T> cmplx<T> sin (const cmplx<T>&);
template<class T> cmplx<T> sinh (const cmplx<T>&);
*/
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;}
/*
template<class T> cmplx<T> tan (const cmplx<T>&);
template<class T> cmplx<T> tanh (const cmplx<T>&);
*/

//non-standard non-member functions
//template operator^: multiplying one complex number with the complex conjugate of another
template<class T> cmplx<T> operator^(const cmplx<T>& a, const cmplx<T>& b){cmplx<T> result=a; result^=b; return result;}

typedef cmplx<double> cdouble;
typedef cmplx<float> cfloat;

#endif