comparison xcomplex.h @ 1:6422640a802f

first upload

+#ifndef XCOMPLEX
+#define XCOMPLEX
+
+
+/*
+  xcomplex.h - Xue's complex number class.
+
+  This classes is modelled after standard c++ complex class, with a few additional methods. Unused
+  standard member and non-member functions/operators may not have been implemented.
+*/
+
+#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; y=0; return *this;}
+  template<class X> cmplx<T>& operator-=(const X& c){x-=c; y=0; 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