KNComplex.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "KNComplex.h"
#include "CKNGlobal.h"

CKNComplex::CKNComplex()
{
    m_fRealNumber = 0.;
    m_fImaginaryNumber = 0.;
}

CKNComplex::~CKNComplex()
{
}

double CKNComplex::GetAbsolute()
{
    double      fRealNumber = GetRealNumber();
    double      fImginaryNumber = GetImaginaryNumber();

    return sqrt( fRealNumber*fRealNumber + fImginaryNumber*fImginaryNumber );
}

CKNComplex CKNComplex::GetConjugate()
{
    CKNComplex      rtnNumber;

    rtnNumber.SetRealNumber(GetRealNumber());
    rtnNumber.SetImaginaryNumber(GetImaginaryNumber() * -1);

    return rtnNumber;
}

void CKNComplex::GetComplexNumber(double *fReal, double *fImaginary)
{
    *fReal = m_fRealNumber;
    *fImaginary = m_fImaginaryNumber;
}

void CKNComplex::SetComplexNumber(double fReal, double fImaginaray)
{
    SetRealNumber(fReal);
    SetImaginaryNumber(fImaginaray);
}

void CKNComplex::Add(CKNComplex complex)
{
    double      fReal, fImaginary;

    fReal = complex.GetRealNumber();
    m_fRealNumber += fReal;
    fImaginary = complex.GetImaginaryNumber();
    m_fImaginaryNumber += fImaginary;
}

void CKNComplex::Minus(CKNComplex complex)
{
    m_fRealNumber -= complex.GetRealNumber();
    m_fImaginaryNumber -= complex.GetImaginaryNumber();
}

void CKNComplex::Division(double fScalar)
{
    m_fRealNumber /= fScalar;
    m_fImaginaryNumber /= fScalar;
}


CKNComplex CKNComplex::AddComplex(CKNComplex complex1, CKNComplex complex2)
{
    CKNComplex      rtnNumber;

    rtnNumber.SetComplexNumber(complex1.GetRealNumber() + complex2.GetRealNumber(), 
                                complex1.GetImaginaryNumber() + complex2.GetImaginaryNumber());
    return rtnNumber;
}

CKNComplex CKNComplex::MinusComplex(CKNComplex complex1, CKNComplex complex2)
{
    CKNComplex      rtnNumber;

    rtnNumber.SetComplexNumber(complex1.GetRealNumber() - complex2.GetRealNumber(), 
                                complex1.GetImaginaryNumber() - complex2.GetImaginaryNumber());
    return rtnNumber;
}

CKNComplex CKNComplex::MulltiplyComplex(CKNComplex complex1, CKNComplex complex2)
{
    CKNComplex      rtnNumber;

    double          realNumber, imaginaryNumber;

    realNumber = complex1.GetRealNumber() * complex2.GetRealNumber() - complex1.GetImaginaryNumber() * complex2.GetImaginaryNumber();
    imaginaryNumber = complex1.GetRealNumber() * complex2.GetImaginaryNumber() + complex1.GetImaginaryNumber() * complex2.GetRealNumber();
    rtnNumber.SetComplexNumber(realNumber, imaginaryNumber);
    return rtnNumber;
}

CKNComplex CKNComplex::DivideComplex(CKNComplex complex1, CKNComplex complex2)
{
    CKNComplex      rtnNumber;

    double          realNumber, imaginaryNumber, d;

    d = complex2.GetRealNumber() * complex2.GetRealNumber() + complex2.GetImaginaryNumber() * complex2.GetImaginaryNumber();

    realNumber = complex1.GetRealNumber() * complex2.GetRealNumber() + complex1.GetImaginaryNumber() * complex2.GetImaginaryNumber();
    realNumber /= d;

    imaginaryNumber = complex1.GetImaginaryNumber() * complex2.GetRealNumber() - complex1.GetRealNumber() * complex2.GetImaginaryNumber();
    imaginaryNumber /= d;

    rtnNumber.SetComplexNumber(realNumber, imaginaryNumber);
    return rtnNumber;
}

void CKNComplex::operator=(const CKNComplex &complexSrc)
{
    SetComplexNumber(complexSrc.GetRealNumber(), complexSrc.GetImaginaryNumber());
}

CKNComplex CKNComplex::operator+(const CKNComplex &complexSrc)
{
    return AddComplex((*this), complexSrc);
}

CKNComplex CKNComplex::operator+=(const CKNComplex &complexSrc)
{
    return AddComplex((*this), complexSrc);
}

CKNComplex CKNComplex::operator-(const CKNComplex &complexSrc)
{
    return MinusComplex((*this), complexSrc);
}

CKNComplex CKNComplex::operator-=(const CKNComplex &complexSrc)
{
    return MinusComplex((*this), complexSrc);
}

CKNComplex CKNComplex::operator*(const CKNComplex &complexSrc)
{
    CKNComplex      rtnValue;

    return MulltiplyComplex((*this), complexSrc);
}

CKNComplex CKNComplex::operator*(double fScalar)
{
    CKNComplex      rtnValue;

    rtnValue.SetComplexNumber(this->GetRealNumber() * fScalar, this->GetImaginaryNumber() * fScalar);
    return rtnValue;
}

CKNComplex CKNComplex::operator*=(const CKNComplex &complexSrc)
{
    CKNComplex      rtnValue;

    return MulltiplyComplex((*this), complexSrc);
}

CKNComplex CKNComplex::operator*=(double fScalar)
{
    CKNComplex      rtnValue;

    rtnValue.SetComplexNumber(this->GetRealNumber() * fScalar, this->GetImaginaryNumber() * fScalar);
    return rtnValue;
}

CKNComplex CKNComplex::operator/(const CKNComplex &complexSrc)
{
    CKNComplex      rtnValue;

    return DivideComplex((*this), complexSrc);
}

CKNComplex CKNComplex::operator/(double fScalar)
{
    CKNComplex      rtnValue;

    rtnValue.SetComplexNumber(this->GetRealNumber() / fScalar, this->GetImaginaryNumber() / fScalar);
    return rtnValue;
}

CKNComplex CKNComplex::operator/=(const CKNComplex &complexSrc)
{
    CKNComplex      rtnValue;

    return DivideComplex((*this), complexSrc);
}

CKNComplex CKNComplex::operator/=(double fScalar)
{
    CKNComplex      rtnValue;

    rtnValue.SetComplexNumber(this->GetRealNumber() / fScalar, this->GetImaginaryNumber() / fScalar);
    return rtnValue;
}

bool CKNComplex::operator==(double fScalar)
{
    CKNComplex          complex;

    complex.SetComplexNumber(fScalar, 0);
    return IsSame(*this, complex);
}

bool CKNComplex::operator==(CKNComplex &complexSrc)
{
    return IsSame(*this, complexSrc);
}

bool CKNComplex::IsSame(CKNComplex complex1, CKNComplex complex2)
{
    bool            bRtn = false;

    if (fabs(complex1.GetRealNumber()- complex2.GetRealNumber()) > GENERAL_TOLERANCE)
        return bRtn;

    if (fabs(complex1.GetImaginaryNumber()- complex2.GetImaginaryNumber()) < GENERAL_TOLERANCE)
        bRtn = true;

    return bRtn;
}