u1.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <uni20/common/half_int.hpp>
#include <uni20/symmetry/symmetryfactor.hpp>
 
#include <concepts>
#include <cstdint>
#include <format>
#include <functional>
#include <iosfwd>
#include <limits>
#include <ostream>
#include <stdexcept>
#include <string>
#include <string_view>
 
namespace uni20
{
 
class U1 {
  public:
    constexpr U1() = default;
 
    constexpr explicit U1(half_int value) : value_(value) {}
 
    template <std::integral T> constexpr U1(T value) : value_(value) {}
 
    template <std::floating_point T> explicit U1(T value) : value_(value) {}
 
    constexpr auto value() const -> half_int { return value_; }
 
    constexpr auto operator<=>(U1 const& other) const = default;
 
  private:
    half_int value_{};
};
 
inline constexpr auto dual(U1 value) -> U1 { return U1{-value.value()}; }
 
inline constexpr auto qdim(U1 value) -> double
{
  static_cast<void>(value);
  return 1.0;
}
 
inline constexpr auto degree(U1 value) -> int
{
  static_cast<void>(value);
  return 1;
}
 
inline constexpr auto operator+(U1 lhs, U1 rhs) -> U1 { return U1{lhs.value() + rhs.value()}; }
 
inline constexpr auto operator-(U1 lhs, U1 rhs) -> U1 { return U1{lhs.value() - rhs.value()}; }
 
inline auto to_string(U1 value) -> std::string { return uni20::to_string(value.value()); }
 
inline auto to_string_fraction(U1 value) -> std::string { return uni20::to_string_fraction(value.value()); }
 
inline auto operator<<(std::ostream& out, U1 value) -> std::ostream&
{
  out << to_string(value);
  return out;
}
 
} // namespace uni20
 
namespace uni20::detail
{
 
template <> struct SymmetryFactorTraits<uni20::U1>
{
    static constexpr auto type_name() -> std::string_view { return "U(1)"; }
 
    static constexpr auto encode(uni20::U1 value) -> std::uint64_t
    {
      auto const twice_value = value.value().twice();
      if (twice_value == 0)
      {
        return 0;
      }
      if (twice_value > 0)
      {
        auto const magnitude = static_cast<std::uint64_t>(twice_value);
        return magnitude * 2 - 1;
      }
 
      if (twice_value == std::numeric_limits<half_int::value_type>::min())
      {
        throw std::overflow_error("U1 encoding cannot represent the most negative half_int value");
      }
 
      auto const magnitude = static_cast<std::uint64_t>(-twice_value);
      return magnitude * 2;
    }
 
    static constexpr auto decode(std::uint64_t code) -> uni20::U1
    {
      if (code == 0)
      {
        return uni20::U1{};
      }
      if ((code & 1U) != 0U)
      {
        return uni20::U1{from_twice(static_cast<half_int::value_type>((code + 1) / 2))};
      }
      return uni20::U1{from_twice(-static_cast<half_int::value_type>(code / 2))};
    }
};
 
inline auto u1_factor() -> SymmetryFactor<uni20::U1> const&
{
  static SymmetryFactor<uni20::U1> factor;
  static auto const* registered = register_symmetry_factor(&factor);
  static_cast<void>(registered);
  return factor;
}
 
inline void register_builtin_symmetry_factors() { static_cast<void>(u1_factor()); }
 
} // namespace uni20::detail
 
template <typename CharT> struct std::formatter<uni20::U1, CharT>
{
    constexpr auto parse(std::basic_format_parse_context<CharT>& ctx) { return ctx.begin(); }
 
    template <typename FormatContext> auto format(uni20::U1 const& value, FormatContext& ctx) const
    {
      return std::format_to(ctx.out(), "{}", uni20::to_string(value));
    }
};
 
template <> struct std::hash<uni20::U1>
{
    auto operator()(uni20::U1 const& value) const noexcept -> std::size_t
    {
      return std::hash<uni20::half_int>{}(value.value());
    }
};