common.inl

Go to the documentation of this file.

/**
 
    @file      common.inl
    @author    Khrapov
    @date      29.04.2023
    @copyright © Nick Khrapov, 2023. All right reserved.
 
**/
 
namespace qx
{
 
template<class T>
constexpr T abs(T value)
{
    return value < 0 ? -value : value;
}
 
template<class T>
constexpr bool epsilon_equal(T left, T right, T eps)
{
    return abs(left - right) < eps;
}
 
template<class T>
constexpr bool epsilon_zero(T value, T eps)
{
    return abs(value) < eps;
}
 
template<class T>
constexpr bool epsilon_less_equal(T left, T right, T eps)
{
    return left < right || epsilon_equal(left, right, eps);
}
 
template<class T>
constexpr bool epsilon_greater_equal(T left, T right, T eps)
{
    return left > right || epsilon_equal(left, right, eps);
}
 
template<std::integral T>
constexpr bool is_odd(T val)
{
    return (val & 1) == 1;
}
 
template<std::integral T>
constexpr bool is_even(T val)
{
    return (val & 1) == 0;
}
 
constexpr int gcd(int nFirst, int nSecond)
{
    if (nFirst == 0 || nSecond == 0)
        return 0;
 
    while (nSecond != 0)
    {
        const int nRemainder = nFirst % nSecond;
        nFirst               = nSecond;
        nSecond              = nRemainder;
    }
 
    return abs(nFirst);
}
 
constexpr int lcm(int nFirst, int nSecond)
{
    if (nFirst == 0 || nSecond == 0)
        return 0;
 
    nFirst  = abs(nFirst);
    nSecond = abs(nSecond);
 
    return nFirst / gcd(nFirst, nSecond) * nSecond;
}
 
template<class T>
constexpr double pow(T number, int nPower)
{
    static_assert(std::is_integral_v<T> || std::is_floating_point_v<T>, "Integral or floating point required");
 
    if (!std::is_constant_evaluated())
    {
        const bool   bNegativePower = nPower < 0;
        const size_t nPositivePower = static_cast<size_t>(std::abs(nPower));
 
        double fResult = 1.0;
        switch (nPositivePower)
        {
        case 0:
            break;
 
        case 1:
            fResult = static_cast<double>(number);
            break;
 
        case 2:
            fResult = static_cast<double>(number * number);
            break;
 
        default:
            const std::bitset<std::numeric_limits<int>::digits> powerBitSet(nPositivePower);
 
            std::array<double, std::numeric_limits<int>::digits> powers;
 
            powers[0] = static_cast<double>(number);
 
            size_t nCurPower = 1;
            size_t nCurIndex = 1;
 
            while (nCurPower < nPositivePower)
            {
                powers[nCurIndex] = powers[nCurIndex - 1] * powers[nCurIndex - 1];
                nCurPower *= 2;
                nCurIndex++;
            }
 
            for (size_t i = 0; i < nCurIndex; ++i)
                if (powerBitSet.test(i))
                    fResult *= powers[i];
 
            break;
        }
 
        return bNegativePower ? 1.0 / fResult : fResult;
    }
    else
    {
        double fResult = 1.0;
        for (int i = 0; i < nPower; ++i)
            fResult *= number;
 
        return fResult;
    }
}
 
template<std::integral I>
I maxpot(I nValue)
{
    static_assert(std::is_integral_v<I>, "Integral required");
 
    if (nValue == 0)
        return 0;
 
    std::bitset<std::numeric_limits<I>::digits> powers(static_cast<size_t>(abs(nValue)));
 
    I nPow = static_cast<I>(std::numeric_limits<I>::digits - 1);
    while (!powers.test(static_cast<size_t>(nPow)))
        --nPow;
 
    return nPow;
}
 
// trick to determine if an integer is between two integers (inclusive)
// with only one comparison/branch
// https://stackoverflow.com/a/17095534/8021662
QX_DISABLE_MSVC_WARNINGS(4018 4388);
 
template<class T, class compare_t>
constexpr bool between(T left, T value, T right, compare_t compare)
{
    if constexpr (std::is_enum_v<T>)
    {
        i64 l = static_cast<i64>(left);
        i64 r = static_cast<i64>(right);
        i64 v = static_cast<i64>(value);
        return between(l, v, r, compare);
    }
    else if constexpr (std::is_integral_v<T> && std::is_same_v<compare_t, std::less_equal<>>)
    {
        return compare(static_cast<size_t>(value - left), right - left);
    }
    else if constexpr (std::is_floating_point_v<T> && std::is_same_v<compare_t, std::less_equal<>>)
    {
        return epsilon_less_equal(left, value) && epsilon_less_equal(value, right);
    }
    else
    {
        return compare(left, value) && compare(value, right);
    }
}
 
template<class T, class compare_t>
constexpr bool between(T left, T value, T right)
{
    QX_PUSH_SUPPRESS_MSVC_WARNINGS(4388);
    return between(left, value, right, compare_t());
    QX_POP_SUPPRESS_WARNINGS();
}
 
QX_RESTORE_MSVC_WARNINGS(4018 4388);
 
} // namespace qx