Move_tracker.hpp

Go to the documentation of this file.

/*******************************************************************************
 Causal Dynamical Triangulations in C++ using CGAL
 
 Copyright © 2021 Adam Getchell
 ******************************************************************************/

 
#ifndef CDT_PLUSPLUS_MOVE_TRACKER_HPP
#define CDT_PLUSPLUS_MOVE_TRACKER_HPP
 
#include <array>
#include <cstddef>
#include <gsl/util>
#include <numeric>
#include <optional>
#include <random>
#include <span>
#include <string_view>
#include <type_traits>
 
#include "Settings.hpp"
 
namespace cdt::move_tracker
{
  inline constexpr std::size_t NUMBER_OF_3D_MOVES = 5;

  enum class [[nodiscard("This contains data!")]] MoveType
  {
    TWO_THREE = 0,  
    THREE_TWO = 1,  
    TWO_SIX   = 2,  
    SIX_TWO   = 3,  
    FOUR_FOUR = 4   
  };

  [[nodiscard]] constexpr auto format_as(MoveType const move) noexcept
      -> std::string_view
  {
    using enum MoveType;
    switch (move)
    {
      case TWO_THREE: return "(2,3)";
      case THREE_TWO: return "(3,2)";
      case TWO_SIX: return "(2,6)";
      case SIX_TWO: return "(6,2)";
      case FOUR_FOUR: return "(4,4)";
    }
    return "unknown";
  }

  template <typename Enumeration>
    requires std::is_enum_v<Enumeration>
  [[nodiscard]] constexpr auto as_integer(Enumeration const value) noexcept
      -> std::underlying_type_t<Enumeration>
  {
    return static_cast<std::underlying_type_t<Enumeration>>(value);
  }  // as_integer

  [[nodiscard]] constexpr auto move_from_index(
      std::size_t const move_choice) noexcept -> std::optional<MoveType>
  {
    using enum MoveType;
    constexpr std::array moves{TWO_THREE, THREE_TWO, TWO_SIX, SIX_TWO,
                               FOUR_FOUR};
    static_assert(moves.size() == NUMBER_OF_3D_MOVES);
    if (move_choice >= moves.size()) { return std::nullopt; }
    return moves[move_choice];
  }  // move_from_index

  template <std::uniform_random_bit_generator Generator>
  [[nodiscard]] inline auto generate_random_move_3(Generator& generator)
      -> MoveType
  {
    std::uniform_int_distribution<int> distribution{
        0, static_cast<int>(NUMBER_OF_3D_MOVES - 1)};
    auto const move_choice = distribution(generator);
    return *move_from_index(static_cast<std::size_t>(move_choice));
  }  // generate_random_move_3

  class MoveTracker
  {
    using Container = std::array<Int_precision, NUMBER_OF_3D_MOVES>;
 
    Container moves = {0};  // NOLINT
 
   public:
    [[nodiscard]] auto moves_view() const noexcept { return std::span(moves); }

    [[nodiscard]] auto operator[](gsl::index const index) -> auto&
    { return gsl::at(moves, index); }  // operator[]

    [[nodiscard]] auto operator[](gsl::index const index) const -> auto const&
    { return gsl::at(moves, index); }  // operator[]

    [[nodiscard]] auto operator[](MoveType const move) -> auto&
    { return gsl::at(moves, as_integer(move)); }  // operator[]

    [[nodiscard]] auto operator[](MoveType const move) const -> auto const&
    { return gsl::at(moves, as_integer(move)); }  // operator[]

    auto operator+=(MoveTracker const& rhs) -> MoveTracker&
    {
      for (std::size_t i = 0; i < moves.size(); ++i)
      {
        moves[i] += rhs.moves[i];
      }
      return *this;
    }  // operator+=

    [[nodiscard]] auto total() const noexcept
    {
      return std::accumulate(moves.begin(), moves.end(), Int_precision{0});
    }  // total

    [[nodiscard]] auto size() const noexcept { return moves.size(); }
 
    // 3D

    [[nodiscard]] auto two_three_moves() -> auto& { return gsl::at(moves, 0); }

    [[nodiscard]] auto two_three_moves() const { return gsl::at(moves, 0); }

    [[nodiscard]] auto three_two_moves() -> auto& { return gsl::at(moves, 1); }

    [[nodiscard]] auto three_two_moves() const { return gsl::at(moves, 1); }

    [[nodiscard]] auto two_six_moves() -> auto& { return gsl::at(moves, 2); }

    [[nodiscard]] auto two_six_moves() const { return gsl::at(moves, 2); }

    [[nodiscard]] auto six_two_moves() -> auto& { return gsl::at(moves, 3); }

    [[nodiscard]] auto six_two_moves() const { return gsl::at(moves, 3); }

    [[nodiscard]] auto four_four_moves() -> auto& { return gsl::at(moves, 4); }

    [[nodiscard]] auto four_four_moves() const { return gsl::at(moves, 4); }

    void reset() { moves.fill(0); }
  };
 
}  // namespace cdt::move_tracker
 
#endif  // CDT_PLUSPLUS_MOVE_TRACKER_HPP