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 <span>
 
#include "Settings.hpp"
#include "Utilities.hpp"
 
namespace move_tracker
{
  static inline Int_precision constexpr NUMBER_OF_3D_MOVES = 5;
  static inline Int_precision constexpr NUMBER_OF_4D_MOVES = 7;
 
  enum class [[nodiscard("This contains data!")]] move_type{
      TWO_THREE = 0, THREE_TWO = 1, TWO_SIX = 2, SIX_TWO = 3, FOUR_FOUR = 4};
 
  template <typename Enumeration>
  auto as_integer(Enumeration value) -> std::underlying_type_t<Enumeration>
  {
    return static_cast<std::underlying_type_t<Enumeration>>(value);
  }  // as_integer
 
  inline auto as_move(int const move_choice) -> move_type
  {
    if (move_choice == 0) { return move_type::TWO_THREE; }
    if (move_choice == 1) { return move_type::THREE_TWO; }
    if (move_choice == 2) { return move_type::TWO_SIX; }
    if (move_choice == 3) { return move_type::SIX_TWO; }
    return move_type::FOUR_FOUR;
  }  // as_move
 
  [[nodiscard]] inline auto generate_random_move_3() -> move_type
  {
    auto move_choice = utilities::generate_random_int(0, 4);
#ifndef NDEBUG
    fmt::print("Move choice = {}\n", move_choice);
#endif
    return as_move(move_choice);
  }  // generate_random_move_3
 
  auto constexpr moves_per_dimension(Int_precision const dim) -> Int_precision
  {
    if (dim == 3) { return NUMBER_OF_3D_MOVES; }
    if (dim == 4) { return NUMBER_OF_4D_MOVES; }
    return 0;  // Error condition
  }  // moves_per_dimension
 
  template <typename ManifoldType>
  class MoveTracker
  {
    using Container =
        std::array<Int_precision, moves_per_dimension(ManifoldType::dimension)>;
 
    Container moves = {0};  // NOLINT
 
   public:
    auto moves_view() const { return std::span(moves); }
 
    auto operator[](gsl::index index) -> auto&
    {
      return gsl::at(moves, index);
    }  // operator[]
 
    auto operator[](move_type const move) const -> auto&
    {
      return gsl::at(moves, as_integer(move));
    }  // operator[]
 
    auto operator+=(MoveTracker const& rhs)
    {
      for (std::size_t i = 0; i < moves.size(); ++i)
      {
        moves[i] += rhs.moves[i];
      }
      return *this;
    }  // operator+=
 
    auto total() const noexcept
    {
      return std::accumulate(moves.begin(), moves.end(), 0);
    }  // total
 
    auto size() const noexcept { return moves.size(); }
 
    // 3D
 
    auto two_three_moves() -> auto& { return gsl::at(moves, 0); }
 
    auto two_three_moves() const { return gsl::at(moves, 0); }
 
    auto three_two_moves() -> auto& { return gsl::at(moves, 1); }
 
    auto three_two_moves() const { return gsl::at(moves, 1); }
 
    auto two_six_moves() -> auto& { return gsl::at(moves, 2); }
 
    auto two_six_moves() const { return gsl::at(moves, 2); }
 
    auto six_two_moves() -> auto& { return gsl::at(moves, 3); }
 
    auto six_two_moves() const { return gsl::at(moves, 3); }
 
    auto four_four_moves() -> auto& { return gsl::at(moves, 4); }
 
    auto four_four_moves() const { return gsl::at(moves, 4); }
 
    // 4D
    auto two_four_moves() -> auto& { return gsl::at(moves, 0); }
 
    auto two_four_moves() const { return gsl::at(moves, 0); }
 
    auto four_two_moves() -> auto& { return gsl::at(moves, 1); }
 
    auto four_two_moves() const { return gsl::at(moves, 1); }
 
    auto three_three_moves() -> auto& { return gsl::at(moves, 2); }
 
    auto three_three_moves() const { return gsl::at(moves, 2); }
 
    auto four_six_moves() -> auto& { return gsl::at(moves, 3); }
 
    auto four_six_moves() const { return gsl::at(moves, 3); }
 
    auto six_four_moves() -> auto& { return gsl::at(moves, 4); }
 
    auto six_four_moves() const { return gsl::at(moves, 4); }
 
    auto two_eight_moves() -> auto& { return gsl::at(moves, 5); }  // NOLINT
 
    auto two_eight_moves() const { return gsl::at(moves, 5); }  // NOLINT
 
    auto eight_two_moves() -> auto& { return gsl::at(moves, 6); }  // NOLINT
 
    auto eight_two_moves() const { return gsl::at(moves, 6); }  // NOLINT
 
    void reset() { moves.fill(0); }
  };
 
}  // namespace move_tracker
 
#endif  // CDT_PLUSPLUS_MOVE_TRACKER_HPP