tb_math.hpp

 
#ifndef TurtleBrains_Math_hpp
#define TurtleBrains_Math_hpp
 
#include <turtle_brains/core/tb_configuration.hpp>
#include <turtle_brains/math/tb_constants.hpp>
 
#include <cmath>
 
namespace TurtleBrains
{
    namespace Math
    {
        template<typename Type> constexpr const Type& Maximum(const Type& leftValue, const Type& rightValue) noexcept
        {
            return (leftValue < rightValue) ? rightValue : leftValue;
        }
 
        template<typename Type> constexpr const Type& Minimum(const Type& leftValue, const Type& rightValue) noexcept
        {
            return (leftValue < rightValue) ? leftValue : rightValue;
        }
 
        template<typename Type> bool IsEqual(const Type& leftValue, const Type& rightValue, const Type tolerance = tbMath::kTolerance)
        {
            // 2024-03-22: While digging into Godot 4.2.1 for porting the SnailedIt prototype, there were some interesting
            //   details found in the implementation of core/math/math_funcs.h is_equal_approx. First they have a specific
            //   check for == directly, which seems to be required to handle infinity values. Then they change tolerance
            //   based on epsilon, (here I renamed epsilon to tolerance), which I believe is to handle greater and greater
            //   precision losses for larger floating point numbers.
            return std::fabs(leftValue - rightValue) <= Maximum<Type>(Type(tolerance), Type(tolerance * std::fabs(leftValue)));
        }
 
        template<typename Type> bool IsZero(const Type& value, const Type tolerance = tbMath::kTolerance)
        {
            return std::fabs(value) <= tolerance;
        }
 
        template<typename Type> constexpr const Type& Clamp(const Type& value, const Type& minimumValue, const Type& maximumValue) noexcept
        {
            return (value < minimumValue) ? minimumValue : (maximumValue < value) ? maximumValue : value;
        }
 
        template<typename Type> Type Sign(const Type& value) noexcept
        {
            return IsZero(value) ? Type(0) : (std::signbit(value) ? Type(-1) : Type(1));
        }
 
    }; /* namespace Math */
}; /* namespace TurtleBrains */
 
namespace tbMath = TurtleBrains::Math;
 
#endif /* TurtleBrains_Math_hpp */