Math.h

// Wykonane przez Piotra Chudzińskiego w dniu 11.04.2025
#pragma once
 
#include "foundation/DataTypes.h"
#include <cmath>
 
template<typename T>
concept Arithmetic = std::is_arithmetic_v<T>;

class Math
{
public:
    const static float PI;

    const static float Epsilon;

    template<Arithmetic T>
    constexpr static T Radians(T value)
    {
        return value * (PI / 180.0f);
    }

    template<Arithmetic T>
    constexpr static T HalfRadians(T value)
    {
        return value * ((PI / 180.0f) * 0.5f);
    }

    template<Arithmetic T>
    constexpr static int32 Ceil(T value)
    {
        int32 intPart = static_cast<int32>(value);
        if (value == static_cast<T>(intPart))
        {
            return intPart;
        }
 
        return value > 0 ? intPart + 1 : intPart;
    }

    template<Arithmetic T>
    constexpr static T Tan(T value)
    {
        return tan(value);
    }

    template<Arithmetic T>
    constexpr static T Sin(T value)
    {
        return sin(value);
    }

    template<Arithmetic T>
    constexpr static T Cos(T value)
    {
        return cos(value);
    }

    template<Arithmetic T>
    constexpr static T Abs(T value)
    {
        return abs(value);
    }

    template<Arithmetic T>
    constexpr static T Inverse(T value)
    {
        if (value > 0)
        {
            return -value;
        }
        else if (value < 0)
        {
            return Abs(value);
        }
        else
        {
            return value;
        }
    }

    template<Arithmetic T>
    constexpr static T Sqrt(T value)
    {
        return sqrt(value);
    }

    template<Arithmetic T>
    constexpr static T Lerp(T from, T to, T amount)
    {
        return from + (to - from) * amount;
    }

    template<Arithmetic T>
    constexpr static T Atan(T x)
    {
        T result = 0.0;
        T term = x;
        T x_squared = x * x;
        int32 n = 1;
 
        for (int32 i = 0; i < 100; ++i)
        {
            if (i % 2 == 0)
            {
                result += term / n;
            }
            else
            {
                result -= term / n;
            }
            term *= x_squared;
            n += 2;
        }
 
        return result;
    };

    template<Arithmetic T>
    constexpr static T Factorical(int32 n)
    {
        if (n == 0 || n == 1)
        {
            return 1;
        }
        T result = 1;
        for (int32 i = 2; i <= n; ++i)
        {
            result *= i;
        }
        return result;
    };

    template<Arithmetic T>
    constexpr static T Asin(T x)
    {
        if (x < -1.0 || x > 1.0)
            return 0;
 
        T result = x;
        T term = x;
        int32 n = 1;
 
        for (int32 i = 1; i < 100; ++i)
        {
            term *= x * x * (2 * n - 1) * (2 * n - 1) / (2 * n * (2 * n + 1));
            result += term;
            ++n;
        }
 
        return result;
    };

    template<Arithmetic T>
    constexpr static T Copysign(T magnitude, T sign)
    {
        return magnitude * (signbit(sign) ? -1.0 : 1.0);
    };

    template<Arithmetic T>
    constexpr static T Atan2(T x, T y)
    {
        if (x > 0)
        {
            return atan(y / x);
        }
        if (x < 0 && y >= 0)
        {
            return atan(y / x) + PI;
        }
        if (x < 0 && y < 0)
        {
            return atan(y / x) - PI;
        }
        if (x == 0 && y > 0)
        {
            return PI / 2;
        }
        if (x == 0 && y < 0)
        {
            return -PI / 2;
        }
 
        return 0;
    };

    template<Arithmetic T>
    constexpr static T Clamp(T value, T min, T max)
    {
        const T& t = value < min ? min : value;
        return t > max ? max : t;
    };
};