Diffpack Documentation

---

              Search  

---

Complex.h

Go to the documentation of this file.

class Complex

{
private:
  real re;
  real im;

public:

  inline real Re() const;
  inline real Im() const;

  Complex ();
  Complex (const Complex& y);
  Complex (real   r, real   i=0);
  
  ~Complex();
  
  Complex& operator =  (const Complex& y);
  Complex& operator += (const Complex& y);
  Complex& operator += (real   y);
  Complex& operator -= (const Complex& y);
  Complex& operator -= (real   y);
  Complex& operator *= (const Complex& y);
  Complex& operator *= (real   y);
  Complex& operator /= (const Complex& y);
  Complex& operator /= (real   y);
};




char*  oform2 (char* s, Complex c);
real   getReal (const Complex& c);

Complex operator /  (const Complex& x, const Complex& y);
Complex operator /  (const Complex& x, real   y);
Complex operator /  (real     x, const Complex& y);

Complex cos(const Complex& x);
Complex sin(const Complex& x);

Complex cosh(const Complex& x);
Complex sinh(const Complex& x);
Complex exp(const Complex& x);

Complex log(const Complex& x);

Complex pow(const Complex& x, int p);
Complex pow(const Complex& x, const Complex& p);
Complex pow(const Complex& x, real   y);
Complex sqrt(const Complex& x);

Is&  operator >> (Is& s, Complex& x);
Os&  operator << (Os& s, const Complex& x);



inline int operator == (const Complex& x, const Complex& y);
inline int operator == (const Complex& x, real   y);
inline int operator != (const Complex& x, const Complex& y);
inline int operator != (const Complex& x, real   y);
inline int operator >  (const Complex& x, const Complex& y);
inline int operator >= (const Complex& x, const Complex& y);
inline int operator <  (const Complex& x, const Complex& y);
inline int operator <= (const Complex& x, const Complex& y);

inline Complex operator - (const Complex& x);
inline Complex conj(const Complex& x);
inline Complex operator + (const Complex& x, const Complex& y);
inline Complex operator + (const Complex& x, real   y);
inline Complex operator + (real   x, const Complex& y);
inline Complex operator - (const Complex& x, const Complex& y);
inline Complex operator - (const Complex& x, real   y);
inline Complex operator - (real   x, const Complex& y);
       Complex operator * (const Complex& x, const Complex& y);
inline Complex operator * (const Complex& x, real   y);
inline Complex operator * (real   x, const Complex& y);

inline real Re(const Complex& x);
inline real Im(const Complex& x);
inline real abs(const Complex& x);
inline real norm(const Complex& x);
inline real arg(const Complex& x);

inline Complex  polar(real   r, real   t = 0.0);




inline real Complex ::Re() const { return re; }
inline real Complex ::Im() const { return im; }



inline Complex ::Complex() { re = im = 0.0; }
inline Complex ::Complex(const Complex& y) :re(y.Re()), im(y.Im()) {}
inline Complex ::Complex(real   r, real   i) :re(r), im(i) {}



inline Complex ::~Complex() {}



inline real Re(const Complex& x)

{
  return x.Re();
}


inline real Im(const Complex& x)

{
  return x.Im();
}


inline real abs(const Complex& x)

{
  return sqrt(x.Re()*x.Re() + x.Im()*x.Im());
}


inline real norm(const Complex& x)

{
  return (x.Re() * x.Re() + x.Im() * x.Im());
}


inline real arg(const Complex& x)

{
  return atan2(x.Im(), x.Re());
}


inline Complex  polar(real   r, real   t)

{
  return Complex(r * cos(t), r * sin(t));
}


inline int operator >  (const Complex& x, const Complex& y)

{
  return (norm(x) > norm(y));
}


inline int operator <  (const Complex& x, const Complex& y)

{
  return (norm(x) < norm(y));
}


inline int operator >=  (const Complex& x, const Complex& y)

{
  return (norm(x) >= norm(y));
}


inline int operator <=  (const Complex& x, const Complex& y)

{
  return (norm(x) <= norm(y));
}


inline Complex&  Complex ::operator =  (const Complex& y)

{
  re = y.Re(); im = y.Im(); return *this;
}


inline Complex&  Complex ::operator += (const Complex& y)

{
  re += y.Re();  im += y.Im(); return *this;
}


inline Complex&  Complex ::operator += (real   y)

{
  re += y; return *this;
}


inline Complex&  Complex ::operator -= (const Complex& y)

{
  re -= y.Re();  im -= y.Im(); return *this;
}


inline Complex&  Complex ::operator -= (real   y)

{
  re -= y; return *this;
}


inline Complex&  Complex ::operator *= (const Complex& y)

{
  real   r = re * y.Re() - im * y.Im();
  im = re * y.Im() + im * y.Re();
  re = r;
  return *this;
}


inline Complex&  Complex ::operator *= (real   y)

{
  re *=  y; im *=  y; return *this;
}




inline int  operator == (const Complex& x, const Complex& y)

{
  return x.Re() == y.Re() && x.Im() == y.Im();
}


inline int  operator == (const Complex& x, real   y)

{
  return x.Im() == 0.0 && x.Re() == y;
}


inline int  operator != (const Complex& x, const Complex& y)

{
  return x.Re() != y.Re() || x.Im() != y.Im();
}


inline int  operator != (const Complex& x, real   y)

{
  return x.Im() != 0.0 || x.Re() != y;
}


inline Complex  operator - (const Complex& x)

{
  return Complex(-x.Re(), -x.Im());
}


inline Complex  conj(const Complex& x)

{
  return Complex(x.Re(), -x.Im());
}


inline Complex  operator + (const Complex& x, const Complex& y)

{
  return Complex(x.Re() + y.Re(), x.Im() + y.Im());
}


inline Complex  operator + (const Complex& x, real   y)

{
  return Complex(x.Re() + y, x.Im());
}


inline Complex  operator + (real   x, const Complex& y)

{
  return Complex(x + y.Re(), y.Im());
}


inline Complex  operator - (const Complex& x, const Complex& y)

{
  return Complex(x.Re() - y.Re(), x.Im() - y.Im());
}


inline Complex  operator - (const Complex& x, real   y)

{
  return Complex(x.Re() - y, x.Im());
}


inline Complex  operator - (real   x, const Complex& y)

{
  return Complex(x - y.Re(), -y.Im());
}


inline Complex  operator * (const Complex& x, real   y)

{
  return Complex(x.Re() * y, x.Im() * y);
}


inline Complex  operator * (real   x, const Complex& y)

{
  return Complex(x * y.Re(), x * y.Im());
}






inline Complex sqr     (Complex a)         { return a*a; }
inline Complex pow3    (Complex a)         { return a*a*a; }
inline Complex pow4    (Complex a)         { Complex b = a*a; return b*b; }

extern Complex pow_int  (Complex a, int i);  
extern bool eq (Complex a, Complex b, real tol = comparison_tolerance);
extern bool lt (Complex a, Complex b, real tol = comparison_tolerance);
extern bool le (Complex a, Complex b, real tol = comparison_tolerance);

#ifdef WIN32
#undef min
#undef max
#endif

inline Complex min(Complex arg1, Complex arg2)
{ return  (arg1 < arg2) ? arg1 : arg2; }

inline Complex max(Complex arg1, Complex arg2)
{ return  (arg1 > arg2) ? arg1 : arg2; }

---