util.h

// By notchcamo.
 
#pragma once
 
#include <limits>

namespace soo::util
{
    constexpr double DEFAULT_TOLERANCE = 1e-8;

    template <typename T>
    requires std::is_arithmetic_v<T>
    bool isEqual(const T a, const T b, const T tolerance = DEFAULT_TOLERANCE)
    {
        return std::abs(a - b) <= tolerance;
    }

    template <std::ranges::range Range>
    requires std::is_arithmetic_v<std::ranges::range_value_t<Range>>
    bool isEqual(const Range& a, const Range& b, const std::ranges::range_value_t<Range> tolerance = DEFAULT_TOLERANCE)
    {
        const auto distA = std::distance(std::cbegin(a), std::cend(a));
        const auto distB = std::distance(std::cbegin(b), std::cend(b));
        if (distA != distB)
        {
            return false;
        }
 
        auto iterA = std::cbegin(a);
        auto iterB = std::cbegin(b);
        while (iterA != std::cend(a))
        {
            if (!isEqual(*iterA, *iterB, tolerance))
            {
                return false;
            }
 
            ++iterA;
            ++iterB;
        }
 
        return true;
    }

    template <typename T>
    requires std::is_arithmetic_v<T>
    bool isZero(const T num, const T tolerance = DEFAULT_TOLERANCE)
    {
        return isEqual(num, static_cast<T>(0), tolerance);
    }

    template <typename T, std::floating_point FP>
    T lerp(const T a, const T b, const FP alpha)
    {
        if (alpha < FP(0) || alpha > FP(1))
        {
            throw std::invalid_argument(
                "The alpha must be ranged from 0 to 1, but given value is " + std::to_string(alpha)
            );
        }
 
        return a * (FP(1) - alpha) + b * alpha;
    }
} // namespace soo::util.