math.hpp

// SPDX-License-Identifier: LGPL-2.1-or-later OR BSD-3-Clause
// SPDX-FileCopyrightText: 2004 - 2008 Olof Naessén and Per Larsson
// SPDX-FileCopyrightText: 2013 - 2026 Fifengine contributors
 
#ifndef INCLUDE_FIFECHAN_MATH_HPP_
#define INCLUDE_FIFECHAN_MATH_HPP_
 
#include <cassert>
#include <cmath>
#include <limits>
#include <numbers>
 
namespace fcn
{
    static float const FLT_STD_EPSILON    = std::numeric_limits<float>::epsilon();
    static float const FLT_STD_MAX        = std::numeric_limits<float>::max();
    static float const FLT_ZERO_TOLERANCE = 1e-06F;
    static float const FLT_PI             = 4.0F * std::atan(1.0F);
    static float const FLT_TWO_PI         = 2.0F * FLT_PI;
    static float const FLT_HALF_PI        = 0.5F * FLT_PI;
    static float const FLT_INVERSE_PI     = 1.0F / FLT_PI;
    static float const FLT_INVERSE_TWO_PI = 1.0F / FLT_TWO_PI;
    static float const FLT_DEG_TO_RAD     = FLT_PI / 180.0F;
    static float const FLT_RAD_TO_DEG     = 180.0F / FLT_PI;
    static float const FLT_LOG_2          = std::numbers::ln2_v<float>;
    static float const FLT_LOG_10         = std::numbers::ln10_v<float>;
    static float const FLT_INV_LOG_2      = 1.0F / std::numbers::ln2_v<float>;
    static float const FLT_INV_LOG_10     = 1.0F / std::numbers::ln10_v<float>;
 
    static double const DBL_STD_EPSILON    = std::numeric_limits<double>::epsilon();
    static double const DBL_STD_MAX        = std::numeric_limits<double>::max();
    static double const DBL_ZERO_TOLERANCE = 1e-08;
    static double const DBL_PI             = 4.0 * std::atan(1.0);
    static double const DBL_TWO_PI         = 2.0 * DBL_PI;
    static double const DBL_HALF_PI        = 0.5 * DBL_PI;
    static double const DBL_INVERSE_PI     = 1.0 / DBL_PI;
    static double const DBL_INVERSE_TWO_PI = 1.0 / DBL_TWO_PI;
    static double const DBL_DEG_TO_RAD     = DBL_PI / 180.0;
    static double const DBL_RAD_TO_DEG     = 180.0F / DBL_PI;
    static double const DBL_LOG_2          = std::numbers::ln2;
    static double const DBL_LOG_10         = std::numbers::ln10;
    static double const DBL_INV_LOG_2      = 1.0 / std::numbers::ln2;
    static double const DBL_INV_LOG_10     = 1.0 / std::numbers::ln10;

    template <class numT>
    struct float_traits
    {
    };

    template <>
    struct float_traits<float>
    {
        using float_type = float; 

        static float_type epsilon()
        {
            return FLT_STD_EPSILON;
        }

        static float_type zeroTolerance()
        {
            return FLT_ZERO_TOLERANCE;
        }

        static float_type max()
        {
            return FLT_STD_MAX;
        }

        static float_type pi()
        {
            return FLT_PI;
        }

        static float_type twoPi()
        {
            return FLT_TWO_PI;
        }

        static float_type halfPi()
        {
            return FLT_HALF_PI;
        }

        static float_type inversePi()
        {
            return FLT_INVERSE_PI;
        }

        static float_type inverseTwoPi()
        {
            return FLT_INVERSE_TWO_PI;
        }

        static float_type degToRad()
        {
            return FLT_DEG_TO_RAD;
        }

        static float_type radToDeg()
        {
            return FLT_RAD_TO_DEG;
        }

        static float_type log2()
        {
            return FLT_LOG_2;
        }

        static float_type log10()
        {
            return FLT_LOG_10;
        }

        static float_type invLog2()
        {
            return FLT_INV_LOG_2;
        }

        static float_type invLog10()
        {
            return FLT_INV_LOG_10;
        }
    };

    template <>
    struct float_traits<double>
    {
        using float_type = double; 

        static float_type epsilon()
        {
            return DBL_STD_EPSILON;
        }

        static float_type zeroTolerance()
        {
            return DBL_ZERO_TOLERANCE;
        }

        static float_type max()
        {
            return DBL_STD_MAX;
        }

        static float_type pi()
        {
            return DBL_PI;
        }

        static float_type twoPi()
        {
            return DBL_TWO_PI;
        }

        static float_type halfPi()
        {
            return DBL_HALF_PI;
        }

        static float_type inversePi()
        {
            return DBL_INVERSE_PI;
        }

        static float_type inverseTwoPi()
        {
            return DBL_INVERSE_TWO_PI;
        }

        static float_type degToRad()
        {
            return DBL_DEG_TO_RAD;
        }

        static float_type radToDeg()
        {
            return DBL_RAD_TO_DEG;
        }

        static float_type log2()
        {
            return DBL_LOG_2;
        }

        static float_type log10()
        {
            return DBL_LOG_10;
        }

        static float_type invLog2()
        {
            return DBL_INV_LOG_2;
        }

        static float_type invLog10()
        {
            return DBL_INV_LOG_10;
        }
    };

    template <typename T>
    class Math
    {
    public:
        using num_type = T;

        using traits_type = float_traits<num_type>;

        static num_type epsilon()
        {
            return traits_type::epsilon();
        }

        static num_type zeroTolerance()
        {
            return traits_type::zeroTolerance();
        }

        static num_type max()
        {
            return traits_type::max();
        }

        static num_type pi()
        {
            return traits_type::pi();
        }

        static num_type twoPi()
        {
            return traits_type::twoPi();
        }

        static num_type halfPi()
        {
            return traits_type::halfPi();
        }

        static num_type inversePi()
        {
            return traits_type::inversePi();
        }

        static num_type inverseTwoPi()
        {
            return traits_type::inverseTwoPi();
        }

        static num_type degToRad()
        {
            return traits_type::degToRad();
        }

        static num_type radToDeg()
        {
            return traits_type::radToDeg();
        }

        static num_type log2()
        {
            return traits_type::log2();
        }

        static num_type log10()
        {
            return traits_type::log10();
        }

        static num_type invLog2()
        {
            return traits_type::invLog2();
        }

        static num_type invLog10()
        {
            return traits_type::invLog10();
        }

        static T ACos(T _val);

        static T ASin(T _val);

        static T ATan(T _val);

        static T ATan2(T _x, T _y);

        static T Ceil(T _val);

        static T Cos(T _val);

        static T Exp(T _val);

        static T FAbs(T _val);

        static T Floor(T _val);

        static T FMod(T _x, T _y);

        static T InvSqrt(T _val);

        static T Log(T _val);

        static T Log2(T _val);

        static T Log10(T _val);

        static T Pow(T _base, T _exponent);

        static T Sin(T _val);

        static T Sqr(T _val);

        static T Sqrt(T _val);

        static T Tan(T _val);

        static bool Equal(T _val1, T _val2);
    };
 
    using Mathf = Math<float>;
    using Mathd = Math<double>;
 
    template <typename T>
    inline T Math<T>::ACos(T _val)
    {
        if (-static_cast<T>(1) < _val) {
            if (_val < static_cast<T>(1)) {
                return static_cast<T>(std::acos(_val));
            }
 
            return static_cast<T>(0);
        }
 
        return pi();
    }
 
    template <class T>
    inline T Math<T>::ASin(T _val)
    {
        if (-static_cast<T>(1) < _val) {
            if (_val < static_cast<T>(1)) {
                return static_cast<T>(std::asin(_val));
            }
 
            return halfPi();
        }
 
        return -halfPi();
    }
 
    template <class T>
    inline T Math<T>::ATan(T _val)
    {
        return static_cast<T>(std::atan(_val));
    }
 
    template <class T>
    inline T Math<T>::ATan2(T _x, T _y)
    {
        return static_cast<T>(std::atan2(_x, _y));
    }
 
    template <class T>
    inline T Math<T>::Ceil(T _val)
    {
        return static_cast<T>(std::ceil(_val));
    }
 
    template <class T>
    inline T Math<T>::Cos(T _val)
    {
        return static_cast<T>(std::cos(_val));
    }
 
    template <class T>
    inline T Math<T>::Exp(T _val)
    {
        return static_cast<T>(std::exp(_val));
    }
 
    template <class T>
    inline T Math<T>::FAbs(T _val)
    {
        return static_cast<T>(std::fabs(_val));
    }
 
    template <class T>
    inline T Math<T>::Floor(T _val)
    {
        return static_cast<T>(std::floor(_val));
    }
 
    template <class T>
    inline T Math<T>::FMod(T _x, T _y)
    {
        return static_cast<T>(std::fmod(_x, _y));
    }
 
    template <class T>
    inline T Math<T>::InvSqrt(T _val)
    {
        return static_cast<T>(1 / std::sqrt(_val));
    }
 
    template <class T>
    inline T Math<T>::Log(T _val)
    {
        return static_cast<T>(std::log(_val));
    }
 
    template <class T>
    inline T Math<T>::Log2(T _val)
    {
        return invLog2() * static_cast<T>(std::log(_val));
    }
    template <class T>
    inline T Math<T>::Log10(T _val)
    {
 
        return invLog10() * static_cast<T>(std::log(_val));
    }
 
    template <class T>
    inline T Math<T>::Pow(T _base, T _exponent)
    {
        return static_cast<T>(std::pow(_base, _exponent));
    }
 
    template <class T>
    inline T Math<T>::Sin(T _val)
    {
        return static_cast<T>(std::sin(_val));
    }
 
    template <class T>
    inline T Math<T>::Sqr(T _val)
    {
        return _val * _val;
    }
 
    template <class T>
    inline T Math<T>::Sqrt(T _val)
    {
        return static_cast<T>(std::sqrt(_val));
    }
 
    template <class T>
    inline T Math<T>::Tan(T _val)
    {
        return static_cast<T>(std::tan(_val));
    }
 
    template <class T>
    inline bool Math<T>::Equal(T _val1, T _val2)
    {
        return std::fabs(_val1 - _val2) < epsilon();
    }

    inline unsigned nextPow2(unsigned x)
    {
        --x;
        x |= x >> 1;
        x |= x >> 2;
        x |= x >> 4;
        x |= x >> 8;
        x |= x >> 16;
        return ++x;
    }
} // namespace fcn
 
#endif // INCLUDE_FIFECHAN_MATH_HPP_