half_int.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <uni20/common/trace.hpp>
#include <uni20/core/numeric_limits.hpp>
 
#include <charconv>
#include <cmath>
#include <compare>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <format>
#include <functional>
#include <ios>
#include <iosfwd>
#include <istream>
#include <limits>
#include <ostream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <system_error>
 
namespace uni20
{
 
template <std::signed_integral T> class basic_half_int {
  public:
    using value_type = T;
 
    struct twice_tag
    {};
 
    constexpr basic_half_int() = default;
 
    template <std::signed_integral U>
    explicit(std::numeric_limits<T>::digits < std::numeric_limits<U>::digits) constexpr basic_half_int(
        basic_half_int<U> other) noexcept(std::numeric_limits<T>::digits >= std::numeric_limits<U>::digits)
    {
      if constexpr (std::numeric_limits<T>::digits < std::numeric_limits<U>::digits)
      {
        if (other.twice() < static_cast<U>(std::numeric_limits<T>::min()) ||
            other.twice() > static_cast<U>(std::numeric_limits<T>::max()))
        {
          throw std::overflow_error("basic_half_int conversion overflow");
        }
      }
      twice_ = static_cast<T>(other.twice());
    }
 
    template <std::integral U> constexpr basic_half_int(U value) : twice_(checked_double(static_cast<T>(value))) {}
 
    template <std::floating_point U> explicit basic_half_int(U value) : twice_(rounded_twice(value)) {}
 
    constexpr basic_half_int(T twice_value, twice_tag tag) : twice_(twice_value) { static_cast<void>(tag); }
 
    constexpr auto twice() const -> T { return twice_; }
 
    constexpr auto is_integral() const -> bool { return (twice_ & T{1}) == 0; }
 
    constexpr auto to_double() const -> double { return static_cast<double>(twice_) / 2.0; }
 
    constexpr auto to_int() const -> T
    {
      if (!this->is_integral())
      {
        throw std::runtime_error("basic_half_int cannot be converted to an integer exactly");
      }
      return twice_ / T{2};
    }
 
    constexpr auto to_int_assert() const -> T
    {
      DEBUG_PRECONDITION(this->is_integral());
      return twice_ / T{2};
    }
 
    constexpr auto operator+=(basic_half_int other) -> basic_half_int&
    {
      twice_ += other.twice_;
      return *this;
    }
 
    constexpr auto operator-=(basic_half_int other) -> basic_half_int&
    {
      twice_ -= other.twice_;
      return *this;
    }
 
    constexpr auto operator++() -> basic_half_int&
    {
      twice_ += T{2};
      return *this;
    }
 
    constexpr auto operator--() -> basic_half_int&
    {
      twice_ -= T{2};
      return *this;
    }
 
    constexpr auto operator++(int) -> basic_half_int
    {
      auto const old = *this;
      ++(*this);
      return old;
    }
 
    constexpr auto operator--(int) -> basic_half_int
    {
      auto const old = *this;
      --(*this);
      return old;
    }
 
    constexpr auto operator<=>(basic_half_int const& other) const = default;
 
    static auto parse(std::string_view text) -> basic_half_int
    {
      if (text.empty())
      {
        throw std::runtime_error("basic_half_int parse failed: empty string");
      }
 
      auto const slash = text.find('/');
      if (slash != std::string_view::npos)
      {
        auto const numerator = parse_integral<T>(text.substr(0, slash));
        auto const denominator = text.substr(slash + 1);
        if (denominator != "2")
        {
          throw std::runtime_error("basic_half_int parse failed: expected denominator 2");
        }
        return from_twice(numerator);
      }
 
      auto const dot = text.find('.');
      if (dot == std::string_view::npos)
      {
        return basic_half_int(parse_integral<T>(text));
      }
 
      auto const whole = text.substr(0, dot);
      auto const fractional = text.substr(dot + 1);
      if (fractional.empty())
      {
        return basic_half_int(parse_integral<T>(whole));
      }
      if (fractional != "0" && fractional != "5")
      {
        throw std::runtime_error("basic_half_int parse failed: expected decimal .0 or .5");
      }
 
      auto const sign = (!whole.empty() && whole.front() == '-') ? T{-1} : T{1};
      auto const twice_whole = checked_double(parse_integral<T>(whole));
      auto const half = (fractional == "5") ? sign : T{0};
      if (half < 0 && twice_whole == std::numeric_limits<T>::min())
      {
        throw std::overflow_error("basic_half_int doubled representation overflow");
      }
      return from_twice(twice_whole + half);
    }
 
  private:
    static constexpr auto from_twice(T twice_value) -> basic_half_int
    {
      return basic_half_int(twice_value, twice_tag{});
    }
 
    static constexpr auto checked_double(T value) -> T
    {
      if (value > std::numeric_limits<T>::max() / T{2} || value < std::numeric_limits<T>::min() / T{2})
      {
        throw std::overflow_error("basic_half_int doubled representation overflow");
      }
      return value * T{2};
    }
 
    template <std::floating_point U> static auto rounded_twice(U value) -> T
    {
      auto const doubled = std::round(static_cast<long double>(value) * 2.0L);
      if (doubled > static_cast<long double>(std::numeric_limits<T>::max()) ||
          doubled < static_cast<long double>(std::numeric_limits<T>::min()))
      {
        throw std::overflow_error("basic_half_int rounded representation overflow");
      }
      return static_cast<T>(doubled);
    }
 
    template <std::integral Int> static auto parse_integral(std::string_view text) -> Int
    {
      if (text.empty())
      {
        throw std::runtime_error("basic_half_int parse failed: missing integer component");
      }
      auto const begin = text.data();
      auto const end = text.data() + text.size();
      Int value{};
      auto const [ptr, ec] = std::from_chars(begin, end, value);
      if (ec != std::errc{} || ptr != end)
      {
        throw std::runtime_error("basic_half_int parse failed: invalid integer component");
      }
      return value;
    }
 
    T twice_ = 0;
};
 
template <std::signed_integral T> struct numeric_limits<basic_half_int<T>>
{
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = true;
    static constexpr bool is_integer = false;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_iec559 = false;
    static constexpr int radix = 2;
    static constexpr int digits() noexcept { return numeric_limits<T>::digits(); }
    static constexpr int digits(basic_half_int<T> const&) noexcept { return digits(); }
    static constexpr int digits(Precision p)
    {
      if (!p.is_exact()) throw std::invalid_argument("half-integer arithmetic requires exact precision");
      return digits();
    }
    static constexpr bool has_infinity = false;
    static constexpr bool has_quiet_NaN = false;
    static constexpr bool has_signaling_NaN = false;
 
    static constexpr basic_half_int<T> lowest() noexcept
    {
      return {numeric_limits<T>::lowest(), typename basic_half_int<T>::twice_tag{}};
    }
 
    static constexpr basic_half_int<T> max() noexcept
    {
      return {numeric_limits<T>::max(), typename basic_half_int<T>::twice_tag{}};
    }
};
 
using half_int = basic_half_int<std::int64_t>;
 
template <std::signed_integral T> constexpr auto from_twice(T twice_value) -> basic_half_int<T>
{
  return basic_half_int<T>(twice_value, typename basic_half_int<T>::twice_tag{});
}
 
template <std::signed_integral T>
constexpr auto operator+(basic_half_int<T> lhs, basic_half_int<T> rhs) -> basic_half_int<T>
{
  lhs += rhs;
  return lhs;
}
 
template <std::signed_integral T>
constexpr auto operator-(basic_half_int<T> lhs, basic_half_int<T> rhs) -> basic_half_int<T>
{
  lhs -= rhs;
  return lhs;
}
 
template <std::signed_integral T> constexpr auto operator-(basic_half_int<T> value) -> basic_half_int<T>
{
  return from_twice<T>(-value.twice());
}
 
template <std::signed_integral T, std::integral U>
constexpr auto operator*(basic_half_int<T> lhs, U rhs) -> basic_half_int<T>
{
  return from_twice<T>(lhs.twice() * static_cast<T>(rhs));
}
 
template <std::integral U, std::signed_integral T>
constexpr auto operator*(U lhs, basic_half_int<T> rhs) -> basic_half_int<T>
{
  return rhs * lhs;
}
 
template <std::signed_integral T, std::floating_point U> constexpr auto operator*(basic_half_int<T> lhs, U rhs) -> U
{
  return static_cast<U>(lhs.to_double()) * rhs;
}
 
template <std::floating_point U, std::signed_integral T> constexpr auto operator*(U lhs, basic_half_int<T> rhs) -> U
{
  return lhs * static_cast<U>(rhs.to_double());
}
 
template <std::signed_integral T> constexpr auto operator*(basic_half_int<T> lhs, basic_half_int<T> rhs) -> double
{
  return lhs.to_double() * rhs.to_double();
}
 
template <std::signed_integral T, std::floating_point U> constexpr auto operator/(basic_half_int<T> lhs, U rhs) -> U
{
  return static_cast<U>(lhs.to_double()) / rhs;
}
 
template <std::signed_integral T> constexpr auto abs(basic_half_int<T> value) -> basic_half_int<T>
{
  return (value.twice() < 0) ? -value : value;
}
 
template <std::signed_integral T> constexpr auto is_integral(basic_half_int<T> value) -> bool
{
  return value.is_integral();
}
 
template <std::signed_integral T> constexpr auto to_int(basic_half_int<T> value) -> T { return value.to_int(); }
 
template <std::signed_integral T> constexpr auto to_int_assert(basic_half_int<T> value) -> T
{
  return value.to_int_assert();
}
 
template <std::signed_integral T> inline auto to_string_fraction(basic_half_int<T> value) -> std::string
{
  if (value.is_integral())
  {
    return std::to_string(value.to_int_assert());
  }
  return std::to_string(value.twice()) + "/2";
}
 
template <std::signed_integral T> inline auto to_string(basic_half_int<T> value) -> std::string
{
  if (value.is_integral())
  {
    return std::to_string(value.to_int_assert());
  }
 
  auto const whole = value.twice() / T{2};
  auto const fractional = (value.twice() < 0 && whole == 0) ? "-0.5" : std::to_string(whole) + ".5";
  return fractional;
}
 
template <std::integral T> constexpr auto minus1pow(T value) -> int
{
  return 1 - static_cast<int>((value & T{1}) << 1);
}
 
template <std::signed_integral T>
constexpr auto is_triangle(basic_half_int<T> a, basic_half_int<T> b, basic_half_int<T> c) -> bool
{
  return (b >= abs(a - c)) && (b <= a + c) && (a + b + c).is_integral();
}
 
template <std::signed_integral T> inline auto operator<<(std::ostream& out, basic_half_int<T> value) -> std::ostream&
{
  out << to_string(value);
  return out;
}
 
template <std::signed_integral T> inline auto operator>>(std::istream& in, basic_half_int<T>& value) -> std::istream&
{
  std::string token;
  in >> token;
  if (!in)
  {
    return in;
  }
 
  try
  {
    value = basic_half_int<T>::parse(token);
  }
  catch (std::runtime_error const&)
  {
    in.setstate(std::ios::failbit);
  }
  return in;
}
 
} // namespace uni20
 
template <std::signed_integral T, typename CharT> struct std::formatter<uni20::basic_half_int<T>, CharT>
{
    constexpr auto parse(std::basic_format_parse_context<CharT>& ctx) { return ctx.begin(); }
 
    template <typename FormatContext> auto format(uni20::basic_half_int<T> const& value, FormatContext& ctx) const
    {
      return std::format_to(ctx.out(), "{}", uni20::to_string(value));
    }
};
 
template <std::signed_integral T> struct std::hash<uni20::basic_half_int<T>>
{
    auto operator()(uni20::basic_half_int<T> const& value) const noexcept -> std::size_t
    {
      return std::hash<T>{}(value.twice());
    }
};