Random.hpp

Go to the documentation of this file.

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

 
#ifndef CDT_PLUSPLUS_RANDOM_HPP
#define CDT_PLUSPLUS_RANDOM_HPP
 
#include <concepts>
#include <cstdint>
#include <limits>
#include <random>
 
#include "pcg_random.hpp"
 
namespace cdt
{
  using Random_seed   = std::uint64_t;
  using Random_stream = std::uint64_t;
 
  namespace random_streams
  {
    inline Random_stream constexpr initialization{0};
    inline Random_stream constexpr transitions{1};
  }  // namespace random_streams

  class Random final
  {
   public:
    using result_type = pcg64::result_type;
 
   private:
    Random_seed               m_seed{};
    Random_stream             m_stream{};
    pcg64                     m_engine;
 
    [[nodiscard]] static auto entropy_seed() -> Random_seed
    {
      std::random_device                         entropy;
      std::uniform_int_distribution<Random_seed> distribution{
          std::numeric_limits<Random_seed>::min(),
          std::numeric_limits<Random_seed>::max()};
      return distribution(entropy);
    }
 
   public:
    Random() : Random{entropy_seed()} {}

    explicit Random(Random_seed const seed, Random_stream const stream = 0)
        : m_seed{seed}, m_stream{stream}, m_engine{seed, stream}
    {}
 
    [[nodiscard]] static auto constexpr min() noexcept -> result_type
    { return pcg64::min(); }
 
    [[nodiscard]] static auto constexpr max() noexcept -> result_type
    { return pcg64::max(); }
 
    [[nodiscard]] auto operator()() -> result_type { return m_engine(); }

    [[nodiscard]] auto seed() const noexcept -> Random_seed { return m_seed; }

    [[nodiscard]] auto stream() const noexcept -> Random_stream
    { return m_stream; }

    [[nodiscard]] auto split(Random_stream const stream) const -> Random
    { return Random{m_seed, stream}; }
  };
 
  static_assert(std::uniform_random_bit_generator<Random>);
}  // namespace cdt
 
#endif  // CDT_PLUSPLUS_RANDOM_HPP