spk_math_utils.hpp

#pragma once
 
#ifndef NOMINMAX
#   define NOMINMAX
#endif
 
#ifndef M_PI
#   define M_PI 3.14159265358979323846
#endif
 
#include <limits>
#include <stdint.h>
 
#include "structure/math/spk_vector2.hpp"
#include "structure/math/spk_vector3.hpp"
#include "structure/math/spk_vector4.hpp"
 
namespace spk
{
    namespace MathUtils
    {
        float degreeToRadian(float p_degrees);
        float radianToDegree(float p_radians);
 
        intmax_t positiveModulo(const intmax_t &p_value, const intmax_t &p_modulo);

        template <typename TScalar>
        struct NumericLimitVector2
        {
            using value_type = IVector2<TScalar>;

            static constexpr bool is_specialized = true;

            static constexpr value_type min() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::min(),
                    std::numeric_limits<TScalar>::min()};
            }

            static constexpr value_type max() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::max(),
                    std::numeric_limits<TScalar>::max()};
            }

            static constexpr value_type lowest() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::lowest(),
                    std::numeric_limits<TScalar>::lowest()};
            }

            static constexpr int digits = std::numeric_limits<TScalar>::digits;
            static constexpr int digits10 = std::numeric_limits<TScalar>::digits10;
            static constexpr int max_digits10 = std::numeric_limits<TScalar>::max_digits10;

            static constexpr bool is_signed = std::numeric_limits<TScalar>::is_signed;
            static constexpr bool is_integer = std::numeric_limits<TScalar>::is_integer;
            static constexpr bool is_exact = std::numeric_limits<TScalar>::is_exact;

            static constexpr int radix = std::numeric_limits<TScalar>::radix;

            static constexpr value_type epsilon() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::epsilon(),
                    std::numeric_limits<TScalar>::epsilon()};
            }

            static constexpr value_type roundError() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::round_error(),
                    std::numeric_limits<TScalar>::round_error()};
            }
        };

        template <typename TScalar>
        struct NumericLimitVector3
        {
            using value_type = IVector3<TScalar>;

            static constexpr bool is_specialized = true;

            static constexpr value_type min() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::min(),
                    std::numeric_limits<TScalar>::min(),
                    std::numeric_limits<TScalar>::min()};
            }

            static constexpr value_type max() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::max(),
                    std::numeric_limits<TScalar>::max(),
                    std::numeric_limits<TScalar>::max()};
            }

            static constexpr value_type lowest() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::lowest(),
                    std::numeric_limits<TScalar>::lowest(),
                    std::numeric_limits<TScalar>::lowest()};
            }

            static constexpr int digits = std::numeric_limits<TScalar>::digits;
            static constexpr int digits10 = std::numeric_limits<TScalar>::digits10;
            static constexpr int max_digits10 = std::numeric_limits<TScalar>::max_digits10;

            static constexpr bool is_signed = std::numeric_limits<TScalar>::is_signed;
            static constexpr bool is_integer = std::numeric_limits<TScalar>::is_integer;
            static constexpr bool is_exact = std::numeric_limits<TScalar>::is_exact;

            static constexpr int radix = std::numeric_limits<TScalar>::radix;

            static constexpr value_type epsilon() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::epsilon(),
                    std::numeric_limits<TScalar>::epsilon(),
                    std::numeric_limits<TScalar>::epsilon()};
            }

            static constexpr value_type roundError() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::round_error(),
                    std::numeric_limits<TScalar>::round_error(),
                    std::numeric_limits<TScalar>::round_error()};
            }
        };

        template <typename TScalar>
        struct NumericLimitVector4
        {
            using value_type = IVector4<TScalar>;

            static constexpr bool is_specialized = true;

            static constexpr value_type min() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::min(),
                    std::numeric_limits<TScalar>::min(),
                    std::numeric_limits<TScalar>::min(),
                    std::numeric_limits<TScalar>::min()};
            }

            static constexpr value_type max() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::max(),
                    std::numeric_limits<TScalar>::max(),
                    std::numeric_limits<TScalar>::max(),
                    std::numeric_limits<TScalar>::max()};
            }

            static constexpr value_type lowest() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::lowest(),
                    std::numeric_limits<TScalar>::lowest(),
                    std::numeric_limits<TScalar>::lowest(),
                    std::numeric_limits<TScalar>::lowest()};
            }

            static constexpr int digits = std::numeric_limits<TScalar>::digits;
            static constexpr int digits10 = std::numeric_limits<TScalar>::digits10;
            static constexpr int max_digits10 = std::numeric_limits<TScalar>::max_digits10;

            static constexpr bool is_signed = std::numeric_limits<TScalar>::is_signed;
            static constexpr bool is_integer = std::numeric_limits<TScalar>::is_integer;
            static constexpr bool is_exact = std::numeric_limits<TScalar>::is_exact;

            static constexpr int radix = std::numeric_limits<TScalar>::radix;

            static constexpr value_type epsilon() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::epsilon(),
                    std::numeric_limits<TScalar>::epsilon(),
                    std::numeric_limits<TScalar>::epsilon(),
                    std::numeric_limits<TScalar>::epsilon()};
            }

            static constexpr value_type roundError() noexcept
            {
                return value_type{
                    std::numeric_limits<TScalar>::round_error(),
                    std::numeric_limits<TScalar>::round_error(),
                    std::numeric_limits<TScalar>::round_error(),
                    std::numeric_limits<TScalar>::round_error()};
            }
        };
    }
}
 
namespace std
{
    template <>
    class numeric_limits<spk::Vector2> : public spk::MathUtils::NumericLimitVector2<spk::Vector2::value_type>
    {
    };
 
    template <>
    class numeric_limits<spk::Vector2Int> : public spk::MathUtils::NumericLimitVector2<spk::Vector2Int::value_type>
    {
    };
 
    template <>
    class numeric_limits<spk::Vector2UInt> : public spk::MathUtils::NumericLimitVector2<spk::Vector2UInt::value_type>
    {
    };
 
    template <>
    class numeric_limits<spk::Vector3> : public spk::MathUtils::NumericLimitVector3<spk::Vector3::value_type>
    {
    };
 
    template <>
    class numeric_limits<spk::Vector3Int> : public spk::MathUtils::NumericLimitVector3<spk::Vector3Int::value_type>
    {
    };
 
    template <>
    class numeric_limits<spk::Vector3UInt> : public spk::MathUtils::NumericLimitVector3<spk::Vector3UInt::value_type>
    {
    };
 
    template <>
    class numeric_limits<spk::Vector4> : public spk::MathUtils::NumericLimitVector4<spk::Vector4::value_type>
    {
    };
 
    template <>
    class numeric_limits<spk::Vector4Int> : public spk::MathUtils::NumericLimitVector4<spk::Vector4Int::value_type>
    {
    };
 
    template <>
    class numeric_limits<spk::Vector4UInt> : public spk::MathUtils::NumericLimitVector4<spk::Vector4UInt::value_type>
    {
    };
}