complex.cpp

DSP图像处理程序源码

#include "stdafx.h"
#include "complex.h"

complex::complex(double re,double im){
	real=re;
	imag=im;
}
complex::complex(){
	real=0.0;
	imag=0.0;
}
complex::complex(const complex& z){
	real=z.real;
	imag=z.imag;
}
double complex::abs(void){
	return xhypot(real,imag);
}
double abs(const complex z){
	return xhypot(z.real,z.imag);
}
double abs(const double r) {
	return fabs (r);
}

double arg (const complex z) {
  return atan2 (z.imag, z.real);
}

double norm (const complex z) {
  return z.real * z.real + z.imag * z.imag;
}

double norm (const double r) {
  return r * r;
}
double complex::re (void) {
  return real;
}

double re (const complex z) {
  return z.real;
}

double re (const double r) {
  return r;
}

double complex::im (void) {
  return imag;
}

double im (const complex z) {
  return z.imag;
}

double im (const double) {
  return 0.0;
}

complex complex::conj (void) {
  return complex (real, -imag);
}

complex conj (const complex z) {
  return complex (z.real, -z.imag);
}

double conj (const double r) {
  return r;
}

complex exp (const complex z) {
	double mag = exp (re (z));
	return complex (mag * cos (im (z)),mag * sin (im (z)));
}
complex sin (const complex z) {
  double r = re (z);
  double i = im (z);
  return (polar (exp (-i), r - M_PI/2) - polar (exp (i), -r - M_PI/2)) / 2.0;
}

complex cos (const complex z) {
  double r = re (z);
  double i = im (z);
  return (polar (exp (-i), r) + polar (exp (i), -r)) / 2.0;
}

complex rect (const double x, const double y) {
  return complex (x, y);
}

complex polar (const complex a, const complex p) {
  return a * exp (rect (p.imag, -p.real));
}

complex polar (const double mag, const double ang) {
  return rect (mag * cos (ang), mag * sin (ang));
}

double xhypot (const double a, const double b) {
  double c = fabs (a);
  double d = fabs (b);
  if (c > d) {
    double e = d / c;
    return c * sqrt (1 + e * e);
  }
  else if (d == 0)
    return 0;
  else {
    double e = c / d;
    return d * sqrt (1 + e * e);
  }
}

double xhypot (const complex a, const complex b) {
 double c = norm (a);
 double d = norm (b);
  if (c > d)
    return abs (a) * sqrt (1 + d / c);
  else if (d == 0)
    return 0;
  else
    return abs (b) * sqrt (1 + c / d);
}

complex pow (const complex z, const double d) {
  return polar (pow (abs (z), d), arg (z) * d);
}

complex complex::operator +(){
	return complex (real,imag);
}

complex complex::operator -(){
	return complex(-real,-imag);
}

complex& complex::operator +=(const complex z) {
	real += z.real;
	imag += z.imag;
	return *this;
}

complex& complex::operator +=(const double r){
	real += r;
	return *this;
}

complex& complex::operator -=(const complex z) {
	real -=z.real;
	imag -=z.imag;
	return *this;
}

complex& complex::operator -=(const double r){
	real -= r;
	return *this;
}

complex& complex::operator*=(const double r) {
  real *= r;
  imag *= r;
  return *this;
}

complex& complex::operator*=(const complex z) {
  double n;
  n = real * z.real - imag * z.imag;
  imag = imag * z.real + real* z.imag;
  real = n;
  return *this;
}

complex& complex::operator =(const complex z){
	real=z.real;
	imag=z.imag;
	return *this;
}

complex& complex::operator=(const double r) {
  real = r;
  imag = 0.0;
  return *this;
}

complex operator+ (const complex z1,const complex z2){
	return complex (z1.real+z2.real,z1.imag+z2.imag);
}

complex operator+ (const double r1,const complex z2){
	return complex (r1+z2.real,z2.imag);
}

complex operator+ (const complex z1,const double r2){
	return complex (z1.real+r2,z1.imag);
}

complex operator- (const complex z1,const complex z2){
	return complex (z1.real-z2.real,z1.imag-z2.imag);
}

complex operator- (const double z1,const complex z2){
	return complex (z1-z2.real,-z2.imag);
}

complex operator- (const complex z1,const double z2){
	return complex (z1.real-z2,z1.imag);
}

complex operator* (const complex z1,const complex z2){
	return complex (z1.real * z2.real - z1.imag * z2.imag, z1.imag * z2.real + z1.real * z2.imag);
}

complex operator*(const complex z1, const double r2) {
  return complex (z1.real * r2, z1.imag * r2);
}

complex operator*(const double r1, const complex z2) {
  return complex (z2.real * r1, z2.imag * r1);
}

complex operator/(const complex z1,const complex z2){
	complex temp;
	temp.real=(z1.real*z2.real+z1.imag*z2.imag)/(z2.real*z2.real+z2.imag*z2.imag);
	temp.imag=(z1.imag*z2.real-z1.real*z2.imag)/(z2.real*z2.real+z2.imag*z2.imag);
	return temp;
}

complex operator/(const double r1, const complex z2){
    return (complex(r1,0)/z2);
}

complex operator/(const complex z1, const double r2) {
	return complex (z1.real/r2,z1.imag/r2);
}

complex operator^(const complex z1, const double r2) {
	return pow(z1,r2);
}

bool operator==(const complex z1, const complex z2) {
  return (z1.real == z2.real) && (z1.imag == z2.imag);
}

bool operator!=(const complex z1, const complex z2) {
  return (z1.real != z2.real) || (z1.imag != z2.imag);
}

void complex::print (void) {
	if (imag>=0)
  cout<<real<<'+'<<imag<<'i'<<endl;
	else 
  cout<<real<<imag<<'i'<<endl;
}

/*Debug

void main()
{
	//example for all the method in this class
	complex x0;									 //create complex 0
	complex x1(0,1.0);							 //create pure i
	complex x2(1.0,2.0);						 //create 1+i
	complex x3(x2);							     //create x3=x2
	x0.print();x1.print();x2.print();x3.print();  //output x0-x3
	
	double abs_x2;
	abs_x2=x2.abs();
	cout<<"x2's abs is "<<abs_x2<<endl;			//use method z.abs() to get magitude
	
	double arg_x2;
	arg_x2=arg(x2);
	cout<<"x2's arg is "<<arg_x2<<endl;			//use arg(z) to get angel
	
	double norm_x2;
	norm_x2=norm(x2);
	cout<<"x2's norm is "<<norm_x2<<endl;		//use norm(z) to get norm 
	
	double re_x2,im_x2;
	re_x2=x2.re();
	im_x2=im(x2);
	cout<<"x2's real part is "<<re_x2<<endl;    //use z.re() or re(z) to get the real part
	cout<<"x2's imag part is "<<im_x2<<endl;	//use z.im() or im(z) to get the imag part
	
	complex conj_x2;
	conj_x2=conj(x2);
	conj_x2.print();							//use z.conj() or conj(z) to get the conjetitude of z
	
	complex exp_x2;
	exp_x2=exp(x2);
	exp_x2.print();								//use exp(z) to get e^z
	
	complex minus_x2;
	minus_x2=-x2;
	minus_x2.print();							//use -z get -z

	complex add_x1_x2;							//as the same in language c to operate double
	add_x1_x2=x1+x2;
	add_x1_x2.print();							//use z1+z2 get z1+z2

	complex sub_x1_x2;						
	sub_x1_x2=x1-x2;							//use z1-z2 get z1-z2
	sub_x1_x2.print();

	complex mul_x1_x2;
	mul_x1_x2=x1*x2;							//use z1*z2 get z1*z2
	mul_x1_x2.print();
	
	int x1_equal_x2;
	x1_equal_x2=(x1==x2);						//z1==z2 judge if z1=z2 return a bool value
	cout<<x1_equal_x2<<endl;

	int x1_notequal_x2;
	x1_notequal_x2=(x1!=x2);					//z1!=z2 judge if z1 not equal to z2 return a bool value
	cout<<x1_notequal_x2<<endl;

	complex divide_x1_x2;
	divide_x1_x2=1/x2;							//use z1/z2 get z1/z2
	divide_x1_x2.print();

	complex x2_twice;
	x2_twice=x2^2.0;
	x2_twice.print();

	
	complex wn=exp(-complex(0,1.0)*2.0*3.141592654/9);
	wn.print();
	complex f2=wn^((double)3*(double)3);
	f2.print();

}

//Debug*/