Complex.hpp

Go to the documentation of this file.

#pragma once
 
#include <Math/math/Functions.hpp>
#include <Math/math/Vector2D.hpp>
#include <Math/math/Angle.hpp>
#include <cassert>
#include <cmath>
#include <complex>
#include <concepts>
#include <type_traits>
 
namespace Math
{
 
template <std::floating_point T>
class BasicComplex
{
public:
    using value_type = T; 
 
    constexpr BasicComplex() = default;
    constexpr BasicComplex(T real_number) : _real(real_number) { } 
    constexpr BasicComplex(T real_part, T imaginary_part) : _real(real_part), _imaginary(imaginary_part) { }
    constexpr BasicComplex(BasicRadian<T> real_part, BasicRadian<T> imaginary_part)
        :
        _real( real_part.value() ),
        _imaginary( imaginary_part.value() )
    {
    }
    constexpr BasicComplex(std::complex<T> c) : _real( std::real(c) ), _imaginary( std::imag(c) ) { } 
 
    constexpr static BasicComplex<T> identity() { return BasicComplex{ T{1}, T{} }; }
 
    constexpr static BasicComplex<T> zero() { return BasicComplex{}; }
    constexpr static BasicComplex<T> unit_real() { return identity(); }
    constexpr static BasicComplex<T> unit_i() { return BasicComplex{ T{}, T{1} }; }
 
    constexpr BasicComplex<T> conjugate() const
    {
        return BasicComplex<T>{ _real, -_imaginary };
    }
 
    BasicComplex<T> pow(T exponent) const
    {
        // NOTE: Because this is a template function, conversion operators are not
        //       considered.  Thus, we directly call this->asStdComplex().
        return std::pow( this->asStdComplex(), exponent );
    }
 
    BasicComplex<T> pow(int exponent) const
    {
        return std::pow( this->asStdComplex(), exponent );
    }
 
    BasicComplex<T> pow(BasicComplex<T> exponent) const
    {
        return std::pow( this->asStdComplex(), exponent.asStdComplex() );
    }
 
    BasicComplex<T> exp() const
    {
        return std::exp( this->asStdComplex() );
    }
 
    BasicComplex<T> log() const
    {
        return std::log( this->asStdComplex() );
    }
 
    BasicComplex<T> log10() const
    {
        return std::log10( this->asStdComplex() );
    }
 
    T    normSquared() const { return accumulate(*this * conjugate()); }
    T    norm() const { return std::sqrt( normSquared() ); }
 
    T    magnitudeSquared() const { return normSquared(); }
    T    magnitude() const { return norm(); }
 
    constexpr BasicComplex<T> normalized() const
    {
        assert( BasicComplex<T>{*this / magnitude()}.isUnit() ); // Verify that we actually return a unit-length BasicComplex
 
        return *this / this->magnitude();
    }
 
    BasicComplex<T> inverse() const { return conjugate() / normSquared(); }
 
    BasicRadian<T> angle() const
    {
        return atan2( BasicRadian<T>( imaginary() ), BasicRadian<T>( real() ) );
    }
 
    constexpr const T &real() const { return _real; }
    constexpr void     real(T r)    { _real = r; }
 
    constexpr const T &i() const { return _imaginary; }
    constexpr void     i(T r)    { _imaginary = r; }
 
    constexpr const T &imaginary() const { return _imaginary; }
    constexpr void     imaginary(T r)    { _imaginary = r; }
 
    bool isUnit() const { return approximately_equal_to( magnitude(), T{1} ); }
    bool isUnit(T tolerance) const { return approximately_equal_to( magnitude(), T{1}, tolerance ); }
 
    bool isZero() const { return approximately_equal_to( magnitude(), T{} ); }
    bool isZero(T tolerance) const { return approximately_equal_to( magnitude(), T{}, tolerance ); }
 
    // Checks if the real() part is 0
    bool isPure() const { return approximately_equal_to(real(), T{}); }
 
    bool isNaN() const
    {
        return std::isnan(_real) || std::isnan(_imaginary);
    }
    bool isInf() const
    {
        return std::isinf(_real) || std::isinf(_imaginary);
    }
 
    constexpr static BasicComplex<T> make_pure(T i) { return BasicComplex<T>{ T{}, i }; }
 
    constexpr static BasicComplex<T> encode_point(T x, T y) { return BasicComplex<T>{ x, y }; }
 
    constexpr static BasicComplex<T> make_rotation(BasicRadian<T> radians)
    {
        return { cos( radians ), sin( radians ) };
    }
 
    constexpr std::complex<T> asStdComplex() const { return std::complex<T>{ _real, _imaginary }; }
 
    operator std::complex<T>() const { return std::complex<T>{ _real, _imaginary }; }
private:
    T _real{};
    T _imaginary{};
 
    friend constexpr bool operator ==(const BasicComplex<T> &left, const BasicComplex<T> &right)
    {
        return approximately_equal_to(left, right);
    }
 
    template <std::floating_point OT = T>
    friend constexpr bool approximately_equal_to(const BasicComplex<T> &value_to_test,
                                                 const BasicComplex<T> &value_it_should_be,
                                                       OT               tolerance = OT{0.0002})
    {
        return approximately_equal_to(value_to_test.real(),      value_it_should_be.real(),      tolerance) &&
               approximately_equal_to(value_to_test.imaginary(), value_it_should_be.imaginary(), tolerance);
    }
 
    friend constexpr BasicComplex<T> operator *(const BasicComplex<T> &left, const BasicComplex<T> &right)
    {
        return { left.real() * right.real() - left.imaginary() * right.imaginary(),
                 left.real() * right.imaginary() + left.imaginary() * right.real() };
    }
 
    template <std::floating_point OT>
    friend constexpr BasicComplex<T> operator *(const BasicComplex<T> &complex, OT scalar)
    {
        return { complex.real() * T(scalar), complex.imaginary() * T(scalar) };
    }
 
    friend constexpr BasicComplex<T> operator /(const BasicComplex<T> &left, const BasicComplex<T> &right)
    {
        return left * right.inverse();
    }
 
    template <std::floating_point OT>
    friend constexpr BasicComplex<T> operator /(const BasicComplex<T> &complex, OT scalar)
    {
        return { complex.real()      / T(scalar),
                 complex.imaginary() / T(scalar) };
    }
 
    friend constexpr BasicComplex<T> operator +(const BasicComplex<T> &left, const BasicComplex<T> &right)
    {
        return { left.real()      + right.real(),
                 left.imaginary() + right.imaginary() };
    }
 
    template <std::floating_point OT>
    friend constexpr BasicComplex<T> operator +(const BasicComplex<T> &complex, OT scalar)
    {
        return { complex.real() + scalar, complex.imaginary() };
    }
 
    friend constexpr BasicComplex<T> operator -(const BasicComplex<T> &left, const BasicComplex<T> &right)
    {
        return { left.real()      - right.real(),
                 left.imaginary() - right.imaginary() };
    }
 
    template <std::floating_point OT>
    friend constexpr BasicComplex<T> operator -(const BasicComplex<T> &complex, OT scalar)
    {
        return { complex.real() - scalar, complex.imaginary() };
    }
 
    friend constexpr BasicComplex<T> operator -(const BasicComplex<T> &q)
    {
        return { -q.real(), -q.imaginary() };
    }
 
    template <std::floating_point OT = T>
    friend bool check_if_equal(const BasicComplex<T> &input,
                               const BasicComplex<T> &near_to,
                                     OT               tolerance = OT{0.0002})
    {
        if (!approximately_equal_to(input, near_to, tolerance))
        {
            auto diff{ near_to - input };
 
            std::cout << std::format("input: {} is not equal to near_to: {} within tolerance: {}.  Difference is {} .",
                                     format(input),
                                     format(near_to),
                                     tolerance,
                                     format(near_to - input))
            << std::endl;
            return  false;
        }
        return true;
    }
 
    template <std::floating_point OT = T>
    friend bool check_if_not_equal(const BasicComplex<T> &input,
                                   const BasicComplex<T> &near_to,
                                         OT               tolerance = OT{0.0002})
    {
        if (approximately_equal_to(input, near_to, tolerance))
        {
            auto diff{ near_to - input };
 
            std::cout << std::format("input: {} is equal to near_to: {} within tolerance: {}.  Difference is {} .",
                                     format(input),
                                     format(near_to),
                                     tolerance,
                                     format(near_to - input))
            << std::endl;
            return  false;
        }
        return true;
    }
 
    template <std::floating_point OT = T>
    friend void CHECK_IF_EQUAL(const BasicComplex<T> &input,
                               const BasicComplex<T> &near_to,
                                     OT               tolerance = OT{0.0002})
    {
        assert( check_if_equal(input, near_to, tolerance) );
    }
 
    template <std::floating_point OT = T>
    friend void CHECK_IF_NOT_EQUAL(const BasicComplex<T> &input,
                                   const BasicComplex<T> &near_to,
                                         OT               tolerance = OT{0.0002})
    {
        assert( check_if_not_equal(input, near_to, tolerance) );
    }
 
    template <std::floating_point OT = T>
    friend void CHECK_IF_ZERO(const BasicComplex<T> &input, OT tolerance = OT{0.0002})
    {
        assert( check_if_equal(input, BasicComplex<T>::zero(), tolerance));
    }
 
    friend constexpr T dot(const BasicComplex<T> &left, const BasicComplex<T> &right)
    {
        return left.real()      * right.real() +
               left.imaginary() * right.imaginary();
    }
 
    friend constexpr T dot_normalized(const BasicComplex<T> &left, const BasicComplex<T> &right)
    {
        return ( left.real()      * right.real() +
                 left.imaginary() * right.imaginary() ) / (left.magnitude() * right.magnitude());
    }
 
    friend constexpr BasicComplex<T> passively_rotate_encoded_point(const BasicComplex<T> &rotation,
                                                                    const BasicComplex<T> &encoded_point)
    {
        assert( rotation.isUnit() );
 
        return rotation * encoded_point;
    }
 
    friend constexpr BasicComplex<T> compose_rotations(const BasicComplex<T> &rotation_1,
                                                       const BasicComplex<T> &rotation_2)
    {
        return rotation_2 * rotation_1;
    }
 
    friend constexpr BasicComplex<T> normalized(const BasicComplex<T> &input)
    {
        return input.normalized();
    }
 
    friend constexpr BasicRadian<T> arg(const BasicComplex<T> &input)
    {
        return input.angle().value();
    }
 
    friend constexpr BasicComplex<T> polar(T m, BasicRadian<T> angle = BasicRadian<T>{})
    {
        return std::polar( m, angle.value() );
    }
 
    friend constexpr T accumulate(const BasicComplex<T> &input)
    {
        return T{input.real() + input.i()};
    }
 
    friend constexpr BasicComplex<T> slerp(const BasicComplex<T> &begin,
                                           const BasicComplex<T> &end,
                                                 T                percent)
    {
        BasicComplex<T> combined{ begin.conjugate() * end };
        BasicComplex<T> powered{ combined.pow(percent) };
        BasicComplex<T> result{ begin * powered };
 
        return result;
    }
 
    friend std::string format(const BasicComplex<T> &input)
    {
        return std::format("[real: {}, i: {}]", input.real(), input.i() );
    }
 
    friend constexpr BasicComplex<T> conjugate(const BasicComplex<T> &input)
    {
        return input.conjugate();
    }
 
    friend constexpr BasicComplex<T> log(const BasicComplex<T> &input)
    {
        return input.log();
    }
 
    friend constexpr BasicComplex<T> log10(const BasicComplex<T> &input)
    {
        return input.log10();
    }
 
    friend BasicComplex<T> exp(const BasicComplex<T> &input)
    {
        return input.exp();
    }
 
    friend BasicComplex<T> pow(const BasicComplex<T> &input, T p)
    {
        return input.pow( p );
    }
 
    friend BasicComplex<T> pow(const BasicComplex<T> &input, int p)
    {
        return input.pow( p );
    }
 
    friend BasicComplex<T> pow(const BasicComplex<T> &input, const BasicComplex<T> &p)
    {
        return input.pow( p );
    }
 
    friend BasicComplex<T> sin(BasicComplex<T> c)
    {
        return std::sin( c.asStdComplex() );
    }
 
    friend BasicComplex<T> cos(BasicComplex<T> c)
    {
        return std::cos( c.asStdComplex() );
    }
 
    friend BasicComplex<T> tan(BasicComplex<T> c)
    {
        return std::tan( c.asStdComplex() );
    }
 
    friend BasicComplex<T> asin(BasicComplex<T> c)
    {
        return std::asin( c.asStdComplex() );
    }
 
    friend BasicComplex<T> acos(BasicComplex<T> c)
    {
        return std::acos( c.asStdComplex() );
    }
 
    friend BasicComplex<T> atan(BasicComplex<T> c)
    {
        return std::atan( c.asStdComplex() );
    }
 
    friend BasicComplex<T> sinh(BasicComplex<T> c)
    {
        return std::sinh( c.asStdComplex() );
    }
 
    friend BasicComplex<T> cosh(BasicComplex<T> c)
    {
        return std::cosh( c.asStdComplex() );
    }
 
    friend BasicComplex<T> tanh(BasicComplex<T> c)
    {
        return std::tanh( c.asStdComplex() );
    }
 
    friend BasicComplex<T> asinh(BasicComplex<T> c)
    {
        return std::asinh( c.asStdComplex() );
    }
 
    friend BasicComplex<T> acosh(BasicComplex<T> c)
    {
        return std::acosh( c.asStdComplex() );
    }
 
    friend BasicComplex<T> atanh(BasicComplex<T> c)
    {
        return std::atanh( c.asStdComplex() );
    }
 
};
 
using Complexf = BasicComplex<float>;
using Complexd = BasicComplex<double>;
using Complex  = BasicComplex<double>;
using Complexl = BasicComplex<long double>;
 
}