src/ComplexNumber.cpp

Go to the documentation of this file.

// Copyright (c) 2010 Matthew Krupcale

// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:

// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.

#ifndef COMPLEX_NUMBER_CPP
#define COMPLEX_NUMBER_CPP

//============================================================================
// Name        : ComplexNumber.cpp
// Author      : Matthew Krupcale
// Version     : 0.1.2
// Copyright   : Copyright (C) 2010 Matthew Krupcale
// Description : A class that deals with complex numbers
//============================================================================

#include "ComplexNumber.h"
#include "MathExceptions.h"
#include "Namespace.h"
#include <iostream>
#include <cmath>

BEGIN_NAMESPACE(math)


BEGIN_NAMESPACE(complex)

template<> const ComplexNumber<double> ComplexNumber<double>::i(0, 1);

template <class T>
ComplexNumber<T>::ComplexNumber() {
    real = 0.;
    imaginary = 0.;
}

template <class T>
ComplexNumber<T>::ComplexNumber(const T& real, const T& imaginary) {
    this->real = real;
    this->imaginary = imaginary;
}

template <class T>
ComplexNumber<T>::ComplexNumber(const ComplexNumber<T>& z) {
    real = z.getReal();
    imaginary = z.getImaginary();
}

template <class T>
ComplexNumber<T>::~ComplexNumber() {

}

template <class T>
ComplexNumber<T>
ComplexNumber<T>::polar(const T& r, const T& theta) {
    return ComplexNumber<T>(r * std::cos(theta), r * std::sin(theta));
}

template <class T>
ComplexNumber<T>
ComplexNumber<T>::operator+() const {
    return ComplexNumber<T>(real, imaginary);
}

template <class T>
ComplexNumber<T>
ComplexNumber<T>::operator-() const {
    return ComplexNumber<T>(-real, -imaginary);
}

template <class T>
template <class U>
ComplexNumber<T>::operator ComplexNumber<U>() const {
    return ComplexNumber<U>((U)(real), (U)(imaginary));
}

template <class T>
template <class U>
ComplexNumber<T>&
ComplexNumber<T>::operator=(const ComplexNumber<U>& z) {
    if (this == &z) {
        return *this;
    }
    real = z.getReal();
    imaginary = z.getImaginary();
    return *this;
}

template <class T>
template <class U>
ComplexNumber<T>&
ComplexNumber<T>::operator=(const U& real) {
    this->real = real;
    imaginary = 0;
    return *this;
}

template <class T>
template <class U>
ComplexNumber<T>&
ComplexNumber<T>::operator+=(const ComplexNumber<U>& z) {
    real += z.getReal();
    imaginary += z.getImaginary();
    return *this;
}

template <class T>
template <class U>
ComplexNumber<T>&
ComplexNumber<T>::operator+=(const U& real) {
    this->real += real;
    return *this;
}

template <class T>
template <class U>
ComplexNumber<T>&
ComplexNumber<T>::operator-=(const ComplexNumber<U>& z) {
    real -= z.getReal();
    imaginary -= z.getImaginary();
    return *this;
}

template <class T>
template <class U>
ComplexNumber<T>&
ComplexNumber<T>::operator-=(const U& real) {
    this->real -= real;
    return *this;
}

template <class T>
template <class U>
ComplexNumber<T>&
ComplexNumber<T>::operator*=(const ComplexNumber<U>& z) {
    real = real * z.getReal() - imaginary * z.getImaginary();
    imaginary = real * z.getImaginary() + imaginary * z.getReal();
    return *this;
}

template <class T>
template <class U>
ComplexNumber<T>&
ComplexNumber<T>::operator*=(const U& real) {
    this->real *= real;
    imaginary *= real;
    return *this;
}

template <class T>
template <class U>
ComplexNumber<T>&
ComplexNumber<T>::operator/=(const ComplexNumber<U>& z) {
    // prevent division by zero
    if (z == 0) {
        throw DivisionByZeroException();
    }
    real = (real * z.getReal() + imaginary * z.getImaginary()) /
        (std::pow(z.getReal(), 2) + std::pow(z.getImaginary(), 2));
    imaginary = (imaginary * z.getReal() - real * z.getImaginary()) /
        (std::pow(z.getReal(), 2) + std::pow(z.getImaginary(), 2));
    return *this;
}

template <class T>
template <class U>
ComplexNumber<T>&
ComplexNumber<T>::operator/=(const U& real) {
    // prevent division by zero
    if (real == 0) {
        throw DivisionByZeroException();
    }
    this->real /= real;
    imaginary /= real;
    return *this;
}

template <class T>
T
ComplexNumber<T>::getReal() const {
    return real;
}

template <class T>
T
ComplexNumber<T>::getImaginary() const {
    return imaginary;
}

template <class T>
void
ComplexNumber<T>::setReal(const T& real) {
    this->real = real;
}

template <class T>
void
ComplexNumber<T>::setImaginary(const T& imaginary) {
    this->imaginary = imaginary;
}

template <class T>
ComplexNumber<T> operator+(const ComplexNumber<T>& lhs,
                           const ComplexNumber<T>& rhs) {
    return ComplexNumber<T>(lhs.getReal() + rhs.getReal(),
                            lhs.getImaginary() + rhs.getImaginary());
}

template <class T>
ComplexNumber<T> operator+(const ComplexNumber<T>& lhs, const T& rhs) {
    return ComplexNumber<T>(lhs.getReal() + rhs, lhs.getImaginary());
}

template <class T>
ComplexNumber<T> operator+(const T& lhs, const ComplexNumber<T>& rhs) {
    return ComplexNumber<T>(lhs + rhs.getReal(), rhs.getImaginary());
}

template <class T>
ComplexNumber<T> operator-(const ComplexNumber<T>& lhs,
                           const ComplexNumber<T>& rhs) {
    return ComplexNumber<T>(lhs.getReal() - rhs.getReal(),
                            lhs.getImaginary() - rhs.getImaginary());
}

template <class T>
ComplexNumber<T> operator-(const ComplexNumber<T>& lhs, const T& rhs) {
    return ComplexNumber<T>(lhs.getReal() - rhs, lhs.getImaginary());
}

template <class T>
ComplexNumber<T> operator-(const T& lhs, const ComplexNumber<T>& rhs) {
    return ComplexNumber<T>(lhs - rhs.getReal(), rhs.getImaginary());
}

template <class T>
ComplexNumber<T> operator*(const ComplexNumber<T>& lhs,
                           const ComplexNumber<T>& rhs) {
    return ComplexNumber<T>(lhs.getReal() * rhs.getReal() -
                            lhs.getImaginary() * rhs.getImaginary(),
                            lhs.getReal() * rhs.getImaginary() +
                            lhs.getImaginary() * rhs.getReal());
}

template <class T>
ComplexNumber<T> operator*(const ComplexNumber<T>& lhs, const T& rhs) {
    return ComplexNumber<T>(lhs.getReal() * rhs, lhs.getImaginary() * rhs);
}

template <class T>
ComplexNumber<T> operator*(const T& lhs, const ComplexNumber<T>& rhs) {
    return ComplexNumber<T>(lhs * rhs.getReal(), lhs * rhs.getImaginary());
}

template <class T>
ComplexNumber<T> operator/(const ComplexNumber<T>& lhs,
                           const ComplexNumber<T>& rhs) {
    // prevent division by zero
    if (rhs == 0) {
        throw DivisionByZeroException();
    }
    return ComplexNumber<T>((lhs.getReal() * rhs.getReal() +
                             lhs.getImaginary() * rhs.getImaginary()) /
                            (std::pow(rhs.getReal(), 2) +
                             std::pow(rhs.getImaginary(), 2)),
                            (lhs.getImaginary() * rhs.getReal() -
                             lhs.getReal() * rhs.getImaginary()) /
                            (std::pow(rhs.getReal(), 2) +
                             std::pow(rhs.getImaginary(), 2)));
}

template <class T>
ComplexNumber<T> operator/(const ComplexNumber<T>& lhs, const T& rhs) {
    // prevent division by zero
    if (rhs == 0) {
        throw DivisionByZeroException();
    }
    return ComplexNumber<T>(lhs.getReal() / rhs, lhs.getImaginary() / rhs);
}

template <class T>
ComplexNumber<T> operator/(const T& lhs, const ComplexNumber<T>& rhs) {
    // prevent division by zero
    if (rhs == 0) {
        throw DivisionByZeroException();
    }
    return ComplexNumber<T>((lhs * rhs.getReal()) /
                            (std::pow(rhs.getReal(), 2) +
                             std::pow(rhs.getImaginary(), 2)),
                            (lhs * rhs.getImaginary()) /
                            (std::pow(rhs.getReal(), 2) +
                             std::pow(rhs.getImaginary(), 2)));
}

template <class T, class U>
bool operator==(const ComplexNumber<T>& lhs, const ComplexNumber<U>& rhs) {
    return (lhs.getReal() == rhs.getReal() &&
            lhs.getImaginary() == rhs.getImaginary());
}

template <class T, class U>
bool operator==(const ComplexNumber<T>& lhs, const U& rhs) {
    return (lhs.getReal() == rhs && lhs.getImaginary() == 0);
}

template <class T, class U>
bool operator==(const T& lhs, const ComplexNumber<U>& rhs) {
    return (lhs == rhs.getReal() && rhs.getImaginary() == 0);
}

template <class T, class U>
bool operator!=(const ComplexNumber<T>& lhs, const ComplexNumber<U>& rhs) {
    return (lhs.getReal() != rhs.getReal() ||
            lhs.getImaginary() != rhs.getImaginary());
}

template <class T, class U>
bool operator!=(const ComplexNumber<T>& lhs, const U& rhs) {
    return (lhs.getReal() != rhs || lhs.getImaginary() != 0);
}

template <class T, class U>
bool operator!=(const T& lhs, const ComplexNumber<U>& rhs) {
    return (lhs != rhs.getReal() || rhs.getImaginary() == 0);
}

template <class U>
std::ostream& operator<<(std::ostream& out, const ComplexNumber<U>& z) {
    if (z.getImaginary() > 0) {
        out << z.getReal() << "+" << z.getImaginary() << "i";
    } else if (z.getImaginary() < 0) {
        out << z.getReal() << "-" << -z.getImaginary() << "i";
    } else {
        out << z.getReal();
    }
    return out;
}

template <class U>
std::istream& operator>>(std::istream& in, ComplexNumber<U>& z) {
    U real, imaginary;
    in >> real >> imaginary;
    z.setReal(real);
    z.setImaginary(imaginary);
    return in;
}

END_NAMESPACE(complex)
END_NAMESPACE(math)

#endif /* COMPLEX_NUMBER_CPP */