Angle.hpp

Go to the documentation of this file.

#pragma once
 
#include <Math/math/Functions.hpp>
#include <cmath>
#include <concepts>
#include <compare>
 
namespace Math
{
 
template <std::floating_point T>
class BasicRadian
{
public:
    using value_type = T; 
 
    constexpr BasicRadian() = default; 
    constexpr BasicRadian(T value) : _value(value) { }
 
    static constexpr BasicRadian<T> zero() { return BasicRadian<T>(); }
 
    T value() const { return _value; }
 
    constexpr BasicRadian<T> &operator +=(const BasicRadian &other)
    {
        _value += other._value;
        return *this;
    }
 
    constexpr BasicRadian<T> &operator -=(const BasicRadian &other)
    {
        _value -= other._value;
        return *this;
    }
 
    constexpr BasicRadian<T> &operator *=(const BasicRadian &other)
    {
        _value *= other._value;
        return *this;
    }
 
    constexpr BasicRadian<T> &operator /=(const BasicRadian &other)
    {
        _value /= other._value;
        return *this;
    }
 
    constexpr BasicRadian<T> &operator /=(const T &other)
    {
        _value /= other;
        return *this;
    }
 
    friend constexpr auto operator <=>(const BasicRadian<T> &left, const BasicRadian<T> &right) = default;
 
    constexpr bool isNaN() const
    {
        return std::isnan(_value);
    }
 
    constexpr bool isInf() const
    {
        return std::isinf(_value);
    }
 
private:
    T _value{};
 
    friend constexpr bool approximately_equal_to(const BasicRadian<T> &value_to_test,
                                                 const BasicRadian<T> &value_it_should_be,
                                                       T               tolerance = T{0.0002})
    {
        return approximately_equal_to(value_to_test.value(), value_it_should_be.value(), tolerance);
    }
 
    friend constexpr BasicRadian<T> operator +(const BasicRadian<T> &left, const BasicRadian<T> &right)
    {
        return BasicRadian<T>{ left.value() + right.value() };
    }
 
    friend constexpr BasicRadian<T> operator -(const BasicRadian<T> &left, const BasicRadian<T> &right)
    {
        return BasicRadian<T>{ left.value() - right.value() };
    }
 
    friend constexpr BasicRadian<T> operator *(const BasicRadian<T> &left, const BasicRadian<T> &right)
    {
        return BasicRadian<T>{ left.value() * right.value() };
    }
 
    friend constexpr BasicRadian<T> operator /(const BasicRadian<T> &left, const BasicRadian<T> &right)
    {
        return BasicRadian<T>{ left.value() / right.value() };
    }
 
    friend constexpr BasicRadian<T> operator -(const BasicRadian<T> &input)
    {
        return BasicRadian{ -input.value() };
    }
 
    friend BasicRadian<T> sin(BasicRadian<T> i)
    {
        return std::sin( i.value() );
    }
 
    friend BasicRadian<T> cos(BasicRadian<T> i)
    {
        return std::cos( i.value() );
    }
 
    friend BasicRadian<T> tan(BasicRadian<T> i)
    {
        return std::tan( i.asStdComplex() );
    }
 
    friend BasicRadian<T> asin(BasicRadian<T> i)
    {
        return std::asin( i.asStdComplex() );
    }
 
    friend BasicRadian<T> acos(BasicRadian<T> i)
    {
        return std::acos( i.asStdComplex() );
    }
 
    friend BasicRadian<T> atan(BasicRadian<T> i)
    {
        return std::atan( i.asStdComplex() );
    }
 
    friend BasicRadian<T> sinh(BasicRadian<T> i)
    {
        return std::sinh( i.asStdComplex() );
    }
 
    friend BasicRadian<T> cosh(BasicRadian<T> i)
    {
        return std::cosh( i.asStdComplex() );
    }
 
    friend BasicRadian<T> tanh(BasicRadian<T> i)
    {
        return std::tanh( i.asStdComplex() );
    }
 
    friend BasicRadian<T> asinh(BasicRadian<T> i)
    {
        return std::asinh( i.asStdComplex() );
    }
 
    friend BasicRadian<T> acosh(BasicRadian<T> i)
    {
        return std::acosh( i.asStdComplex() );
    }
 
    friend BasicRadian<T> atanh(BasicRadian<T> i)
    {
        return std::atanh( i.asStdComplex() );
    }
 
    friend BasicRadian<T> atan2(BasicRadian<T> y, BasicRadian<T> x)
    {
        return std::atan2( y.value(), x.value() );
    }
};
 
 
template <std::floating_point T>
class BasicDegree
{
public:
    using value_type = T; 
 
    constexpr BasicDegree() = default; 
    constexpr BasicDegree(T value) : _value(value) { }
    constexpr BasicDegree(const BasicRadian<T> &value) : _value( RadiansToDegrees(value.value()) ) { }
 
    operator BasicRadian<T>() const { return BasicRadian<T>{ DegreesToRadians(_value) }; }
 
    static constexpr BasicDegree<T> zero() { return BasicDegree<T>(); }
 
    T value() const { return _value; }
 
    constexpr BasicDegree<T> &operator +=(const BasicDegree<T> &other)
    {
        _value += other.value();
        return *this;
    }
 
    constexpr BasicDegree<T> &operator +=(const T &other)
    {
        _value += other;
        return *this;
    }
 
    constexpr BasicDegree<T> &operator -=(const BasicDegree<T> &other)
    {
        _value -= other.value();
        return *this;
    }
 
    constexpr BasicDegree<T> &operator -=(const T &other)
    {
        _value -= other;
        return *this;
    }
 
    constexpr BasicDegree<T> &operator *=(const BasicDegree<T> &other)
    {
        _value *= other.value();
        return *this;
    }
 
    constexpr BasicDegree<T> &operator *=(const T &other)
    {
        _value *= other;
        return *this;
    }
 
    constexpr BasicDegree<T> &operator /=(const BasicDegree<T> &other)
    {
        _value /= other.value();
        return *this;
    }
 
    constexpr BasicDegree<T> &operator /=(const T &other)
    {
        _value /= other;
        return *this;
    }
 
    friend constexpr auto operator <=>(const BasicDegree<T> &left, const BasicDegree<T> &right) = default;
 
    static constexpr T modulus() { return 360; }
    constexpr BasicDegree<T> modulo() const
    {
        T modded;
 
        // Make in range of 0 - 360
        return BasicDegree<T>{ (0.0 <= (modded = std::fmod( _value, modulus() )) ? modded : modulus() + modded) };
    }
 
    constexpr bool isNaN() const
    {
        return std::isnan(_value);
    }
 
    constexpr bool isInf() const
    {
        return std::isinf(_value);
    }
 
private:
    T _value{};
 
    friend constexpr bool approximately_equal_to(const BasicDegree<T> &value_to_test,
                                                 const BasicDegree<T> &value_it_should_be,
                                                       T               tolerance = T{0.0002})
    {
        return approximately_equal_to(value_to_test.value(), value_it_should_be.value(), tolerance);
    }
 
    friend constexpr BasicDegree<T> operator +(const BasicDegree<T> &left, const BasicDegree<T> &right)
    {
        return { left.value() + right.value() };
    }
 
    friend constexpr BasicDegree<T> operator -(const BasicDegree<T> &left, const BasicDegree<T> &right)
    {
        return { left.value() - right.value() };
    }
 
    friend constexpr BasicDegree<T> operator *(const BasicDegree<T> &left, const BasicDegree<T> &right)
    {
        return { left.value() * right.value() };
    }
 
    friend constexpr BasicDegree<T> operator /(const BasicDegree<T> &left, const BasicDegree<T> &right)
    {
        return { left.value() / right.value() };
    }
 
    friend constexpr BasicDegree<T> operator +(const BasicDegree<T> &left, const T &right)
    {
        return { left.value() + right };
    }
 
    friend constexpr BasicDegree<T> operator -(const BasicDegree<T> &left, const T &right)
    {
        return { left.value() - right };
    }
 
    friend constexpr BasicDegree<T> operator *(const BasicDegree<T> left, const T &right)
    {
        return { left.value() * right };
    }
 
    friend constexpr BasicDegree<T> operator /(const BasicDegree<T> &left, const T &right)
    {
        return { left.value() / right };
    }
 
    friend constexpr BasicDegree<T> operator -(const BasicDegree<T> &input)
    {
        return { -input.value() };
    }
};
 
 
namespace Literals
{
 
constexpr BasicDegree<float> operator ""_deg_f(long double degrees)
{
    return BasicDegree<float>{ static_cast<float>(degrees) };
}
 
constexpr BasicDegree<float> operator ""_deg_F(long double degrees)
{
    return BasicDegree<float>{ static_cast<float>(degrees) };
}
 
constexpr BasicDegree<float> operator ""_degf(long double degrees)
{
    return BasicDegree<float>{ static_cast<float>(degrees) };
}
 
constexpr BasicDegree<float> operator ""_degF(long double degrees)
{
    return BasicDegree<float>{ static_cast<float>(degrees) };
}
 
constexpr BasicDegree<double> operator ""_deg(long double degrees)
{
    return BasicDegree<double>{ static_cast<double>(degrees) };
}
 
constexpr BasicDegree<long double> operator ""_deg_l(long double degrees)
{
    return BasicDegree<long double>{degrees};
}
 
constexpr BasicDegree<long double> operator ""_deg_L(long double degrees)
{
    return BasicDegree<long double>{degrees};
}
 
constexpr BasicDegree<long double> operator ""_degl(long double degrees)
{
    return BasicDegree<long double>{degrees};
}
 
constexpr BasicDegree<long double> operator ""_degL(long double degrees)
{
    return BasicDegree<long double>{degrees};
}
 
}
 
namespace Literals
{
 
constexpr BasicRadian<float> operator ""_rad_f(long double radians)
{
    return BasicRadian<float>{ static_cast<float>(radians) };
}
 
constexpr BasicRadian<float> operator ""_rad_F(long double radians)
{
    return BasicRadian<float>{ static_cast<float>(radians) };
}
 
constexpr BasicRadian<float> operator ""_radf(long double radians)
{
    return BasicRadian<float>{ static_cast<float>(radians) };
}
 
constexpr BasicRadian<float> operator ""_radF(long double radians)
{
    return BasicRadian<float>{ static_cast<float>(radians) };
}
 
constexpr BasicRadian<double> operator ""_rad(long double radians)
{
    return BasicRadian<double>{ static_cast<double>(radians) };
}
 
constexpr BasicRadian<long double> operator ""_rad_l(long double radians)
{
    return BasicRadian<long double>{radians};
}
 
constexpr BasicRadian<long double> operator ""_rad_L(long double radians)
{
    return BasicRadian<long double>{radians};
}
 
constexpr BasicRadian<long double> operator ""_radl(long double radians)
{
    return BasicRadian<long double>{radians};
}
 
constexpr BasicRadian<long double> operator ""_radL(long double radians)
{
    return BasicRadian<long double>{radians};
}
 
}
 
using Degreef  = BasicDegree<float>;
using Degreed  = BasicDegree<double>;
using Degree   = BasicDegree<double>;
using Degreel  = BasicDegree<long double>;
 
using Radianf  = BasicRadian<float>;
using Radiand  = BasicRadian<double>;
using Radian   = BasicRadian<double>;
using Radianl  = BasicRadian<long double>;
 
}