complex.h

《C++ Builder 5技术内幕》一书附带的程序源代码

//---------------------------------------------------------------------------
#ifndef ComplexH
#define ComplexH

#include <math.h>

template < typename T > class TComplex // : public TObject
{
    friend T norm( const TComplex<T>& rhs );
    friend T abs( const TComplex<T>& rhs );
    friend T conj( const TComplex<T>& rhs );
    friend TComplex<T> operator + ( const TComplex<T>& rhs1, const TComplex<T>& rhs2 );
    friend TComplex<T> operator - ( const TComplex<T>& rhs1, const TComplex<T>& rhs2 );
    friend TComplex<T> operator * ( const TComplex<T>& rhs1, const TComplex<T>& rhs2 );
    friend TComplex<T> operator / ( const TComplex<T>& rhs1, const TComplex<T>& rhs2 );
    friend bool operator == ( const TComplex<T>& rhs1, const TComplex<T>& rhs2 );
    friend bool operator != ( const TComplex<T>& rhs1, const TComplex<T>& rhs2 );
  public:
    typedef T value_type;
    TComplex();
    TComplex( const T& re_arg = 0, const T& imag_arg = 0 );
    TComplex( const TComplex<T>& rhs );
//    ~TComplex();
  public:
    T GetImag() const;
    T GetReal() const;
    TComplex<T>& operator =  ( const T rhs );
    TComplex<T>& operator =  ( const TComplex<T>& rhs );
    TComplex<T>& operator += ( const T rhs );
    TComplex<T>& operator += ( const TComplex<T>& rhs );
    TComplex<T>& operator -= ( const T rhs );
    TComplex<T>& operator -= ( const TComplex<T>& rhs );
    TComplex<T>& operator *= ( const T rhs );
    TComplex<T>& operator *= ( const TComplex<T>& rhs );
    TComplex<T>& operator /= ( const T rhs );
    TComplex<T>& operator /= ( const TComplex<T>& rhs );
  private:
    T FReal, FImag;
};

//------------------------------------------------------------
// Constructors and destructor
//
template < typename T > inline TComplex<T>::TComplex()
{
  FReal = 0;
  FImag = 0;
}

template < typename T > inline TComplex<T>::TComplex( const T& re_arg = 0, const T& imag_arg = 0 )
{
  FReal = re_arg;
  FImag = imag_arg;
}

template < typename T > inline TComplex<T>::TComplex( const TComplex<T>& rhs )
{
  FReal = rhs.FReal;
  FImag = rhs.FImag;
}

//template < typename T > inline TComplex<T>::~TComplex()
//{
//  ;
//}

//------------------------------------------------------------
// Properties functions
//
template < typename T > inline T TComplex<T>::GetImag() const
{
  return FImag;
}

template < typename T > inline T TComplex<T>::GetReal() const
{
  return FReal;
}

//------------------------------------------------------------
// overloaded operator functions
//
template < typename T > inline TComplex<T>& TComplex<T>::operator = ( const T rhs )
{
  FReal = rhs;
  FImag = 0.0;
  return *this;
}

template < typename T > inline TComplex<T>& TComplex<T>::operator += ( const T rhs )
{
  FReal += rhs;
  return *this;
}

template < typename T > inline TComplex<T>& TComplex<T>::operator -= ( const T rhs )
{
  FReal -= rhs;
  return *this;
}

template < typename T > inline TComplex<T>& TComplex<T>::operator *= ( const T rhs )
{
  FReal = FReal * rhs;
  FImag = FImag * rhs;
  return *this;
}

template < typename T > inline TComplex<T>& TComplex<T>::operator /= ( const T rhs )
{
  T denom = rhs * rhs;
  T re = ( FReal * rhs ) / denom;
  T im = ( FImag * im_ ) / denom;
  FReal = re;
  FImag = im;
  return *this;
}

template < typename T > inline TComplex<T>& TComplex<T>::operator = ( const TComplex<T>& rhs )
{
  FReal = rhs.FReal;
  FImag = rhs.FImag;
  return *this;
}

template < typename T > inline TComplex<T>& TComplex<T>::operator += ( const TComplex<T>& rhs )
{
  FReal += rhs.FReal;
  FImag += rhs.FImag;
  return *this;
}

template < typename T > inline TComplex<T>& TComplex<T>::operator -= ( const TComplex<T>& rhs )
{
  FReal -= rhs.FReal;
  FImag -= rhs.FImag;
  return *this;
}

template < typename T > inline TComplex<T>& TComplex<T>::operator *= ( const TComplex<T>& rhs )
{
  T re_temp = FReal;
  T im_temp = FImag;
  FReal = re_temp * rhs.FReal - im_temp * rhs.FImag;
  FImag = re_temp * rhs.FImag + im_temp * rhs.FReal;
  return *this;
}

template < typename T > inline TComplex<T>& TComplex<T>::operator /= ( const TComplex<T>& rhs )
{
  T re_temp  = FReal;
  T im_temp  = FImag;
  T norm_temp = abs( rhs );
  FReal = ( re_temp * rhs.FReal + im_temp * rhs.FImag ) / norm_temp;
  FImag = ( - re_temp * rhs.FImag + im_temp * rhs.FReal ) / norm_temp;
  return *this;
}

//------------------------------------------------------------
// overloaded friend operator functions
//
template < typename T > inline T norm( const TComplex<T>& rhs )
{
    return rhs.GetReal() * rhs.GetReal() + rhs.GetImag() * rhs.GetImag();
}

template < typename T > inline T abs( const TComplex<T>& rhs )
{
  return ( sqrt( norm( rhs ) ) );
}

template < typename T > TComplex<T> conj( const TComplex<T>& rhs )
{
    return TComplex<T>( rhs.GetReal(), - rhs.GetImag() );
}

template < typename T > inline TComplex<T> operator + ( const TComplex<T>& rhs1, const TComplex<T>& rhs2 )
{
  T re_temp, im_temp;
  re_temp = rhs1.FReal + rhs2.FReal;
  im_temp = rhs1.FImag + rhs2.FImag;
  return TComplex<T>( re_temp, im_temp );
}

template < typename T > inline TComplex<T> operator - ( const TComplex<T>& rhs1, const TComplex<T>& rhs2 )
{
  T re_temp, im_temp;
  re_temp = rhs1.FReal - rhs2.FReal;
  im_temp = rhs1.FImag - rhs2.FImag;
  return TComplex<T>( re_temp, im_temp );
}

template < typename T > inline TComplex<T> operator * ( const TComplex<T>& rhs1, const TComplex<T>& rhs2 )
{
  T re_temp, im_temp;
  re_temp = rhs1.FReal * rhs2.FReal - rhs1.FImag * rhs2.FImag;
  im_temp = rhs1.FReal * rhs2.FImag + rhs1.FImag * rhs2.FReal;
  return TComplex<T>( re_temp, im_temp );
}

template < typename T > inline TComplex<T> operator / ( const TComplex<T>& rhs1, const TComplex<T>& rhs2 )
{
  T re_temp, im_temp;
  T norm_temp = norm( rhs2 );
  re_temp = ( rhs1.FReal * rhs2.FReal + rhs1.FImag * rhs2.FImag ) / norm_temp;
  im_temp = ( - rhs1.FReal * rhs2.FImag + rhs1.FImag * rhs2.FReal ) / norm_temp;
  return TComplex<T>( re_temp, im_temp );
}

template < typename T > inline bool operator == ( const TComplex<T>& rhs1, const TComplex<T>& rhs2 )
{
  if( ( rhs1.FReal == rhs2.FReal ) && ( rhs1.FImag == rhs2.FImag ) )
    return true;
  else
    return false;
}

template < typename T > inline bool operator != ( const TComplex<T>& rhs1, const TComplex<T>& rhs2 )
{
  if( ( rhs1.FReal == rhs2.FReal ) && ( rhs1.FImag == rhs2.FImag ) )
    return false;
  else
    return true;
}

//---------------------------------------------------------------------------
#endif