d_cmplx.h

digital filter designer s handbook header files

//
//  file = d_cmplx.h
//

#ifndef _DOUBLE_COMPLEX_H_
#define _DOUBLE_COMPLEX_H_ 

#include <math.h>

class double_complex
{
public:
  double_complex(double _r, double _i=0.0);
  double_complex(float _r, float _i);
  double_complex();
  void operator+= (const double_complex);
  void operator*= (const double_complex);
  void operator*= (double);
  void operator/= (double);
  
  friend double real(const double_complex&);
  friend double imag(const double_complex&);
  friend double_complex sqrt(const double_complex);
  friend double norm(const double_complex);
  friend double mag(const double_complex);
  friend double arg(const double_complex);
  friend double_complex cexp(const double_complex);
  friend double mag_sqrd(const double_complex);
  friend double_complex operator- (const double_complex);
  friend double_complex operator+ (const double_complex, const double_complex);
  friend double_complex operator- (const double_complex, const double_complex);
  friend double_complex operator* (const double_complex, const double_complex);
  friend double_complex operator* (const double_complex, double);
  friend double_complex operator* (double, const double_complex);
  friend double_complex operator/ (const double_complex, const double_complex);
  friend double_complex operator/ (const double_complex, double);
  friend double_complex operator/ (double, const double_complex);
  
private:
  double re, im;
  
};

inline double_complex::double_complex( double _r, double _i) : re(_r), im(_i) { }
inline double_complex::double_complex( float _r, float _i) 
                      : re((double)_r), im((double)_i) { }
inline double_complex::double_complex() : re(0.0), im(0.0) { }
inline void double_complex::operator+= (const double_complex _z)
       { re += _z.re; im += _z.im; }
inline void double_complex::operator*= (double _v) {re *= _v; im *= _v; }
inline void double_complex::operator*= (const double_complex value)
  {
    double real_part;
    re = (real_part = re) * value.re - im * value.im;
    im = real_part * value.im + im * value.re;
  }                                           
inline double real(const double_complex& _z) { return _z.re; }
inline double imag(const double_complex& _z) { return _z.im; } 
inline double norm(const double_complex _z) { return sqrt(_z.re*_z.re + _z.im*_z.im); }
inline double mag(const double_complex _z) { return sqrt(_z.re*_z.re + _z.im*_z.im); }
inline double mag_sqrd(const double_complex _z) { return _z.re*_z.re + _z.im*_z.im; }
inline double arg(const double_complex _z) { return (double)atan2( (double)_z.im, 
                                                                   (double)_z.re); }

inline double_complex cexp( const double_complex _z)
  {
  double re_res, im_res;
  re_res = exp(_z.re)*cos(_z.im);
  im_res = exp(_z.im)*sin(_z.im);
  return(double_complex(re_res, im_res));
  }

inline double_complex sqrt( const double_complex _z)
  {
    double r, theta, re_res, im_res;
    r = sqrt(sqrt(_z.re*_z.re + _z.im*_z.im));
    theta = atan2( _z.im, _z.re)/2.0;
    re_res = r*cos(theta);
    im_res = r*sin(theta);
    return(double_complex(re_res, im_res));
  }
inline double_complex operator- (const double_complex _z)
  { return double_complex(-_z.re, -_z.im); }

inline double_complex operator+ ( const double_complex _z1,
                                 const double_complex _z2)
  { return double_complex( _z1.re + _z2.re, _z1.im + _z2.im);} 

inline double_complex operator- ( const double_complex _z1, 
                                 const double_complex _z2)
  { return double_complex( _z1.re - _z2.re, _z1.im - _z2.im); }

inline double_complex operator* (const double_complex _z1, double _v2)
  { return double_complex( _z1.re * _v2, _z1.im * _v2); }
  
inline double_complex operator* (double _v1, const double_complex _z2)
  { return double_complex(_z2.re * _v1, _z2.im * _v1); }
  
inline double_complex operator/ (const double_complex z1, double v2)
  { return double_complex(z1.re/v2, z1.im/v2); }
  
inline double_complex operator* ( const double_complex value1,
                                 const double_complex value2)
  {
    double real, imag;
    real = value1.re * value2.re - value1.im * value2.im;
    imag = value1.re * value2.im + value1.im * value2.re;
    return double_complex(real, imag);
  }                                  
  
#include <iostream.h>

ostream& operator<< (ostream&, const double_complex&);
istream& operator>> (istream&, double_complex&);

static const double_complex double_complex_zero(0.0, 0.0);

#endif // _double_complex_H_