symmetryfactor.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <stdexcept>
#include <string>
#include <string_view>
#include <unordered_map>
 
namespace uni20::detail
{
 
class SymmetryFactorBase {
  public:
    virtual ~SymmetryFactorBase() = default;
 
    virtual auto type_name() const -> std::string_view = 0;
 
    virtual auto dual_code(std::uint64_t code) const -> std::uint64_t = 0;
 
    virtual auto qdim_code(std::uint64_t code) const -> double = 0;
 
    virtual auto degree_code(std::uint64_t code) const -> int = 0;
 
    virtual auto add_codes(std::uint64_t lhs, std::uint64_t rhs) const -> std::uint64_t = 0;
 
    virtual auto format_code(std::uint64_t code) const -> std::string = 0;
};
 
template <typename Q> struct SymmetryFactorTraits;
 
template <typename Q> class SymmetryFactor final : public SymmetryFactorBase {
  public:
    auto encode(Q const& value) const -> std::uint64_t { return SymmetryFactorTraits<Q>::encode(value); }
 
    auto decode(std::uint64_t code) const -> Q { return SymmetryFactorTraits<Q>::decode(code); }
 
    auto type_name() const -> std::string_view override { return SymmetryFactorTraits<Q>::type_name(); }
 
    auto dual_code(std::uint64_t code) const -> std::uint64_t override
    {
      return this->encode(dual(this->decode(code)));
    }
 
    auto qdim_code(std::uint64_t code) const -> double override { return qdim(this->decode(code)); }
 
    auto degree_code(std::uint64_t code) const -> int override { return degree(this->decode(code)); }
 
    auto add_codes(std::uint64_t lhs, std::uint64_t rhs) const -> std::uint64_t override
    {
      return this->encode(this->decode(lhs) + this->decode(rhs));
    }
 
    auto format_code(std::uint64_t code) const -> std::string override { return to_string(this->decode(code)); }
};
 
inline auto symmetry_factor_registry() -> std::unordered_map<std::string, SymmetryFactorBase const*>&
{
  static std::unordered_map<std::string, SymmetryFactorBase const*> registry;
  return registry;
}
 
inline auto register_symmetry_factor(SymmetryFactorBase const* factor) -> SymmetryFactorBase const*
{
  symmetry_factor_registry().emplace(std::string{factor->type_name()}, factor);
  return factor;
}
 
inline auto find_symmetry_factor(std::string_view type_name) -> SymmetryFactorBase const*
{
  auto const it = symmetry_factor_registry().find(std::string{type_name});
  if (it == symmetry_factor_registry().end())
  {
    throw std::invalid_argument("unsupported symmetry factor type: " + std::string{type_name});
  }
  return it->second;
}
 
} // namespace uni20::detail