phasor.h

Go to the documentation of this file.

 
 
#ifndef THEORETICA_PHASOR
#define THEORETICA_PHASOR
 
#ifndef THEORETICA_NO_PRINT
#include <sstream>
#include <ostream>
#endif
 
#include "../core/real_analysis.h"
#include "./complex.h"
 
 
namespace theoretica {
 
 
    template<typename Type = real>
    class phasor {
        public:
 
            Type modulus;
 
            Type phase;
 
 
            phasor() : phase(0), modulus(0) {}
 
 
            phasor(Type modulus, Type phase) {
                this->phase = phase;
                this->modulus = modulus;
            }
 
 
            phasor(const phasor& other) {
                phase = other.phase;
                modulus = other.modulus;
            }
 
            template<typename T>
            phasor(const complex<T>& z) {
                phase = z.arg();
                modulus = z.norm();
            }
 
            phasor(Type r) {
                modulus = abs(r);
                phase = (r >= 0 ? 0 : PI);
            }
 
 
            inline phasor& operator=(const phasor& z) {
                phase = z.phase;
                modulus = z.modulus;
                return *this;
            }
 
 
            template<typename T>
            inline phasor& operator=(const std::array<T, 2>& v) {
                modulus = v[0];
                phase = v[1];
                return *this;
            }
 
 
            ~phasor() = default;
 
 
            inline Type Re() const {
                return modulus * cos(phase);
            }
 
 
            inline friend Type Re(const phasor& z) {
                return z.Re();
            }
 
 
            inline Type Im() const {
                return modulus * sin(phase);
            }
 
 
            inline friend Type Im(const phasor& z) {
                return z.Im();
            }
 
 
            inline phasor conjugate() const {
                return phasor(modulus, -phase);
            }
 
 
            inline Type sqr_norm() const {
                return modulus * modulus;
            }
 
 
            inline Type norm() const {
                return modulus;
            }
 
 
            inline phasor inverse() const {
 
                if(modulus < MACH_EPSILON) {
                    TH_MATH_ERROR("phasor::inverse", modulus, MathError::DivByZero);
                    return (Type) nan();
                }
 
                return phasor(
                    ((Type) 1.0) / modulus,
                    -phase
                );
            }
 
 
            inline phasor& invert() {
 
                if(modulus < MACH_EPSILON) {
                    TH_MATH_ERROR("phasor::invert", modulus, MathError::DivByZero);
                    modulus = (Type) nan();
                    phase = (Type) nan();
                    return *this;
                }
 
                phase = phase * -1;
                modulus = ((Type) 1.0) / modulus;
                return *this;
            }
 
 
            inline Type arg() const {
                return phase;
            }
 
 
            inline phasor operator+(const phasor& other) const {
 
                if(abs(phase - other.phase) < MACH_EPSILON)
                    return phasor(modulus + other.modulus, phase);
 
                return phasor(to_complex() + other.to_complex());
            }
 
 
            inline phasor operator-(const phasor& other) const {
 
                if(abs(phase - other.phase) < MACH_EPSILON)
                    return phasor(modulus - other.modulus, phase);
 
                return phasor(to_complex() - other.to_complex());
            }
 
 
            inline phasor operator*(const phasor& other) const {
                return phasor(
                    modulus * other.modulus,
                    phase + other.phase);
            }
 
 
            template<typename T>
            inline phasor operator*(const complex<T>& other) const {
                return phasor(
                    modulus * other.norm(),
                    phase + other.arg());
            }
 
 
            template<typename T>
            inline friend phasor operator*(const complex<T>& z, const phasor& w) {
                return phasor(
                    z.norm() * w.modulus,
                    z.arg() + w.phase
                );
            }
 
 
            inline phasor operator/(const phasor& other) const {
 
                if(abs(other.modulus) < MACH_EPSILON) {
                    TH_MATH_ERROR("phasor::operator/", other.modulus, MathError::DivByZero);
                    return phasor(nan(), nan());
                }
                    
 
                return phasor(
                    modulus / other.modulus,
                    phase - other.phase);
            }
 
 
            inline phasor& operator+=(const phasor& other) {
 
                if(phase == other.phase) {
                    modulus += other.modulus;
                } else {
                    *this = phasor(to_complex() + other.to_complex());
                }
 
                return *this;
            }
 
 
            inline phasor& operator-=(const phasor& other) {
 
                if(phase == other.phase)
                    modulus -= other.modulus;
                else
                    *this = phasor(to_complex() - other.to_complex());
 
                return *this;
            }
 
 
            inline phasor& operator*=(const phasor& other) {
 
                modulus *= other.modulus;
                phase += other.phase;
 
                return *this;
            }
 
 
            inline phasor& operator/=(const phasor& other) {
 
                if(abs(other.modulus) < MACH_EPSILON) {
                    TH_MATH_ERROR("phasor::operator/=", other.modulus, MathError::DivByZero);
                    modulus = nan();
                    phase = nan();
                    return *this;
                }
 
                modulus /= other.modulus;
                phase -= other.phase;
 
                return *this;
            }
 
 
            inline bool operator==(const phasor& z) const {
                return (modulus == z.modulus) && (phase == z.phase);
            }
 
 
            inline bool operator!=(const phasor& z) const {
                return !(*this == z);
            }
 
 
            template<typename T = Type>
            complex<T> to_complex() const {
                return complex<T>(
                    modulus * cos(phase),
                    modulus * sin(phase));
            }
 
 
            template<typename T>
            inline operator complex<T> () {
                return to_complex<T>();
            }
 
 
            inline static phasor rotor(Type rad) {
                return phasor((Type) 1.0, rad);
            }
 
 
            inline static phasor i() {
                return phasor(1, PI / 2.0);
            }
 
 
            // Friend operators to enable equations of the form
            // (real) op. (phasor)
 
            inline friend phasor operator+(Type r, const phasor& z) {
                return z + phasor(r);
            }
 
            inline friend phasor operator-(Type r, const phasor& z) {
                return phasor(z.modulus, z.phase + PI) + phasor(r);
            }
 
            inline friend phasor operator*(Type r, const phasor& z) {
                return z * phasor(r);
            }
 
            inline friend phasor operator/(Type r, const phasor& z) {
                return phasor(r) / z;
            }
 
 
#ifndef THEORETICA_NO_PRINT
 
            inline std::string to_string(const std::string& separator = ", ") const {
 
                std::stringstream res;
                res << modulus << "/" << phase;
                return res.str();
            }
 
 
            inline operator std::string() {
                return to_string();
            }
 
 
            inline friend std::ostream& operator<<(std::ostream& out, const phasor& obj) {
                return out << obj.to_string();
            }
 
#endif
 
    };
 
}
 
#endif