numeric_limits.hpp

Go to the documentation of this file.

#pragma once
 
#include "precision.hpp"
#include <limits>
#include <type_traits>
 
namespace uni20
{
 
template <typename T> struct numeric_limits;
 
template <typename T>
  requires(std::is_arithmetic_v<T> && std::numeric_limits<T>::is_specialized)
struct numeric_limits<T> : std::numeric_limits<T>
{
    using std::numeric_limits<T>::epsilon;
 
    static constexpr int digits() noexcept { return std::numeric_limits<T>::digits; }
    static constexpr int digits(T const&) noexcept { return digits(); }
    static constexpr int digits(Precision p)
    {
      require_precision(p);
      return digits();
    }
 
    static constexpr int digits10() noexcept { return std::numeric_limits<T>::digits10; }
    static constexpr int digits10(T const&) noexcept { return digits10(); }
    static constexpr int digits10(Precision p)
    {
      require_precision(p);
      return digits10();
    }
 
    static constexpr int max_digits10() noexcept { return std::numeric_limits<T>::max_digits10; }
    static constexpr int max_digits10(T const&) noexcept { return max_digits10(); }
    static constexpr int max_digits10(Precision p)
    {
      require_precision(p);
      return max_digits10();
    }
 
    static constexpr T epsilon(Precision p)
    {
      require_precision(p);
      return std::numeric_limits<T>::epsilon();
    }
 
    template <class U>
      requires(std::is_same_v<T, U> && std::numeric_limits<T>::is_specialized)
    static constexpr T epsilon(U const&) noexcept
    {
      return std::numeric_limits<T>::epsilon();
    }
 
  private:
    static constexpr void require_precision(Precision p)
    {
      auto native = std::numeric_limits<T>::is_exact ? Precision::exact() : Precision::bits(digits());
      if (p != native) throw std::invalid_argument("fixed-precision scalar requires its native precision");
    }
};
 
template <typename T>
  requires requires { numeric_limits<T>::is_specialized; }
struct numeric_limits<T const> : numeric_limits<T>
{};
 
template <typename T>
  requires requires { numeric_limits<T>::is_specialized; }
struct numeric_limits<T volatile> : numeric_limits<T>
{};
 
template <typename T>
  requires requires { numeric_limits<T>::is_specialized; }
struct numeric_limits<T const volatile> : numeric_limits<T>
{};
 
template <typename T>
inline constexpr bool has_numeric_limits_v =
    requires { requires numeric_limits<std::remove_cvref_t<T>>::is_specialized; };
 
template <class T>
  requires(requires(T const& x) { x.is_exact(); } || has_numeric_limits_v<T>)
constexpr bool is_exact(T const& x)
{
  if constexpr (requires { x.is_exact(); })
    return x.is_exact();
  else
    return numeric_limits<T>::is_exact;
}
 
} // namespace uni20