limits.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_CORE_VALUE_LIMITS_H
#define pRC_CORE_VALUE_LIMITS_H
 
#include <prc/core/basic/functions/zero.hpp>
#include <prc/core/basic/limits.hpp>
#include <prc/core/value/float.hpp>
#include <prc/core/value/value.hpp>
 
namespace pRC
{
    template<IsValue T>
    struct NumericLimits<T>
    {
    private:
        using F = typename T::Fundamental;
 
    public:
        static constexpr Size digits()
        {
            return std::numeric_limits<F>::digits;
        }
 
        static constexpr T min()
        {
            return std::numeric_limits<F>::min();
        }
 
        static constexpr T max()
        {
            return std::numeric_limits<F>::max();
        }
 
        static constexpr T lowest()
        {
            return std::numeric_limits<F>::lowest();
        }
 
        static constexpr T epsilon()
        {
            return std::numeric_limits<F>::epsilon();
        }
 
        static constexpr T tolerance()
        {
            if constexpr(IsSame<T, Float<64>>)
            {
                return 1e-12;
            }
            if constexpr(IsSame<T, Float<32>>)
            {
                return 1e-5f;
            }
 
            return zero<T>();
        }
    };
 
    template<>
    struct NumericLimits<Float<16>>
    {
        static constexpr Size digits()
        {
            return 7;
        }
 
        static constexpr Float<16> min()
        {
            return BFloat16::FromRepresentation(0x0080);
        }
 
        static constexpr Float<16> max()
        {
            return BFloat16::FromRepresentation(0x7F7F);
        }
 
        static constexpr Float<16> lowest()
        {
            return BFloat16::FromRepresentation(0xFF7F);
        }
 
        static constexpr Float<16> epsilon()
        {
            return BFloat16::FromRepresentation(0x3C00);
        }
 
        static constexpr Float<16> tolerance()
        {
            return BFloat16::FromRepresentation(0x3C24);
        }
    };
}
#endif // pRC_CORE_VALUE_LIMITS_H