spk_safe_comparand.hpp

#pragma once
 
#include <algorithm>
#include <cmath>
 
#include "structure/math/spk_constants.hpp"
 
namespace spk
{
    template <typename TType, bool IsFloat = std::is_floating_point_v<TType>>
    struct SafeComparand;

    template <typename TType>
    struct SafeComparand<TType, false>
    {
        static_assert(std::is_arithmetic_v<TType>, "TType must be arithmetic");
        using value_type = TType;

        TType value{};

        SafeComparand() = default;

        explicit SafeComparand(const TType &p_value) :
            value(p_value)
        {
        }
    };

    template <typename TType>
    struct SafeComparand<TType, true>
    {
        static_assert(std::is_floating_point_v<TType>, "TType must be floating");

        TType value{};
        TType epsilon{static_cast<TType>(spk::Math::Constants::pointPrecision)};

        SafeComparand() = default;

        explicit SafeComparand(const TType &p_value) :
            value(p_value)
        {
        }

        SafeComparand(const TType &p_value, const TType &p_epsilon) :
            value(p_value),
            epsilon(p_epsilon)
        {
        }
    };
 
    template <class T>
    SafeComparand(T) -> SafeComparand<std::remove_cv_t<std::remove_reference_t<T>>, std::is_floating_point_v<std::remove_cv_t<std::remove_reference_t<T>>>>;
 
    template <class T, class U>
    SafeComparand(T, U) -> SafeComparand<std::remove_cv_t<std::remove_reference_t<T>>, std::is_floating_point_v<std::remove_cv_t<std::remove_reference_t<T>>>>;
 
    template <typename TLeftHandType, bool IsLeftHandleFloatingType, typename TRightHandType>
        requires(std::is_arithmetic_v<TLeftHandType> && std::is_arithmetic_v<TRightHandType>)
    constexpr bool operator==(const SafeComparand<TLeftHandType, IsLeftHandleFloatingType> &p_lhs, const TRightHandType &p_rhs)
    {
        using Common = std::common_type_t<TLeftHandType, TRightHandType>;
 
        if constexpr (IsLeftHandleFloatingType)
        {
            const Common dv = static_cast<Common>(p_lhs.value) - static_cast<Common>(p_rhs);
            const Common eps = static_cast<Common>(p_lhs.epsilon);
            return std::abs(dv) <= eps;
        }
        else
        {
            if constexpr (std::is_floating_point_v<TRightHandType>)
            {
                const Common dv = static_cast<Common>(p_lhs.value) - static_cast<Common>(p_rhs);
                const Common eps = static_cast<Common>(spk::Math::Constants::pointPrecision);
                return std::abs(dv) <= eps;
            }
            else
            {
                return p_lhs.value == static_cast<TLeftHandType>(p_rhs);
            }
        }
    }
 
    template <typename TLeftHandType, typename TRightHandType, bool IsRightHandFloatingType>
        requires(std::is_arithmetic_v<TLeftHandType> && std::is_arithmetic_v<TRightHandType>)
    constexpr bool operator==(const TLeftHandType &p_lhs, const SafeComparand<TRightHandType, IsRightHandFloatingType> &p_rhs)
    {
        return (p_rhs == p_lhs);
    }
 
    template <typename TLeftHandType, bool IsLeftHandFloatingType, typename TRightHandType, bool IsRightHandFloatingType>
        requires(std::is_arithmetic_v<TLeftHandType> && std::is_arithmetic_v<TRightHandType>)
    constexpr bool operator==(
        const SafeComparand<TLeftHandType, IsLeftHandFloatingType> &p_lhs, const SafeComparand<TRightHandType, IsRightHandFloatingType> &p_rhs)
    {
        using Common = std::common_type_t<TLeftHandType, TRightHandType>;
        if constexpr (IsLeftHandFloatingType || IsRightHandFloatingType)
        {
            const Common dv = static_cast<Common>(p_lhs.value) - static_cast<Common>(p_rhs.value);
            Common eps{};
            if constexpr (IsLeftHandFloatingType && IsRightHandFloatingType)
            {
                eps = std::min<Common>(static_cast<Common>(p_lhs.epsilon), static_cast<Common>(p_rhs.epsilon));
            }
            else if constexpr (IsLeftHandFloatingType)
            {
                eps = static_cast<Common>(p_lhs.epsilon);
            }
            else
            {
                eps = static_cast<Common>(p_rhs.epsilon);
            }
            return std::abs(dv) <= eps;
        }
        else
        {
            return static_cast<Common>(p_lhs.value) == static_cast<Common>(p_rhs.value);
        }
    }
 
    template <typename TLeftHandType, bool IsLeftHandFloatingType, typename TRightHandType>
        requires(std::is_arithmetic_v<TLeftHandType> && std::is_arithmetic_v<TRightHandType>)
    constexpr bool operator!=(const SafeComparand<TLeftHandType, IsLeftHandFloatingType> &p_lhs, const TRightHandType &p_rhs)
    {
        return !(p_lhs == p_rhs);
    }
 
    template <typename TLeftHandType, typename TRightHandType, bool IsRightHandFloatingType>
        requires(std::is_arithmetic_v<TLeftHandType> && std::is_arithmetic_v<TRightHandType>)
    constexpr bool operator!=(const TLeftHandType &p_lhs, const SafeComparand<TRightHandType, IsRightHandFloatingType> &p_rhs)
    {
        return !(p_lhs == p_rhs);
    }
 
    template <typename TLeftHandType, bool IsLeftHandFloatingType, typename TRightHandType, bool IsRightHandFloatingType>
        requires(std::is_arithmetic_v<TLeftHandType> && std::is_arithmetic_v<TRightHandType>)
    constexpr bool operator!=(
        const SafeComparand<TLeftHandType, IsLeftHandFloatingType> &p_lhs, const SafeComparand<TRightHandType, IsRightHandFloatingType> &p_rhs)
    {
        return !(p_lhs == p_rhs);
    }
}