random.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>  
#include <chrono>  
#include <iterator>  
#include <limits>  
#include <random>
#include <stdexcept>  
#include <vector>
 
#include <cpp-toolbox/type_traits.hpp>
 
namespace toolbox::utils
{
 
class random_t
{
public:
  random_t()
  {
    std::random_device rd;
    engine_.seed(rd());
  }
 
  explicit random_t(unsigned int seed_val)
      : engine_(seed_val)
  {
  }
 
  static random_t& instance()
  {
    static random_t instance;
    return instance;
  }
 
  void seed()
  {
    std::random_device rd;
    engine_.seed(rd());
  }
 
  void seed(unsigned int s) { engine_.seed(s); }
 
  int randint(int a, int b)
  {
    if (a > b) {  // Python的randint行为/Python's randint behavior
      std::swap(a, b);
    }
    std::uniform_int_distribution<int> dist(a, b);
    return dist(engine_);
  }
 
  template<typename T>
  T random_int(T a, T b)
  {
    static_assert(
        std::is_integral_v<T>,
        "random_int<T>(T,T) 仅支持整数类型/only supports integral types");
    if (a > b) {  // Python的randint行为/Python's randint behavior
      std::swap(a, b);
    }
    std::uniform_int_distribution<T> dist(a, b);
    return dist(engine_);
  }
 
  template<typename T>
  T random_float(T a, T b)
  {
    static_assert(std::is_floating_point_v<T>,
                  "random_float<T>(T,T) 仅支持浮点类型/only supports floating "
                  "point types");
    std::uniform_real_distribution<T> dist(a, b);
    return dist(engine_);
  }
 
  template<typename T>
  T random(T a, T b)
  {
    if constexpr (std::is_integral_v<T>) {
      return random_int(a, b);
    } else if constexpr (std::is_floating_point_v<T>) {
      return random_float(a, b);
    } else {
      static_assert(std::is_integral_v<T> || std::is_floating_point_v<T>,
                    "random<T>(T,T) 仅支持整数和浮点类型/only supports "
                    "integral and floating point types");
      return T {};  // 这行代码永远不会执行，只是为了避免编译错误/This line will
                    // never execute, just to avoid compile error
    }
  }
 
  template<typename T>
  T random()
  {
    if constexpr (std::is_floating_point_v<T>) {
      return random_float<T>(0, 1);
    } else if constexpr (std::is_integral_v<T>) {
      return random_int<T>(0, std::numeric_limits<T>::max());
    } else {
      static_assert(std::is_floating_point_v<T> || std::is_integral_v<T>,
                    "random<T>() 仅支持浮点和整数类型/only supports floating "
                    "point and integral types");
      return T {};  // 这行代码永远不会执行，只是为了避免编译错误/This line will
                    // never execute, just to avoid compile error
    }
  }
 
  template<typename T>
  T uniform(T a, T b)
  {
    std::uniform_real_distribution<T> dist(a, b);
    return dist(engine_);
  }
 
  template<typename T>
  T gauss(T mu, T sigma)
  {
    static_assert(
        std::is_floating_point_v<T>,
        "gauss<T>(T,T) 仅支持浮点类型/only supports floating point types");
    std::normal_distribution<T> dist(mu, sigma);
    return dist(engine_);
  }
 
  template<typename T>
  T choice(const std::vector<T>& vec)
  {
    if (vec.empty()) {
      throw std::out_of_range(
          "无法从空vector中选择/Cannot choose from an empty vector");
    }
    // randint是闭区间[a, b]，vector索引是[0, size-1]/randint is inclusive [a,
    // b], vector index is [0, size-1]
    return vec[randint(0, static_cast<int>(vec.size()) - 1)];
  }
 
  template<typename TContainer>
  typename TContainer::value_type choice_general(const TContainer& container)
  {
    static_assert(toolbox::traits::is_iterable_v<TContainer>,
                  "choice_general<TContainer> 仅支持可迭代容器/only supports "
                  "iterable containers");
    if (container.empty()) {
      throw std::out_of_range(
          "无法从空容器中选择/Cannot choose from an empty container");
    }
    std::uniform_int_distribution<size_t> dist(0, container.size() - 1);
    auto it = container.begin();
    std::advance(it, dist(engine_));
    return *it;
  }
 
  template<typename TContainer>
  void shuffle(TContainer& container)
  {
    std::shuffle(container.begin(), container.end(), engine_);
  }
 
  template<typename TContainer>
  TContainer sample(const TContainer& population, size_t k)
  {
    if (k > population.size()) {
      throw std::out_of_range(
          "k不能大于容器大小/k cannot be greater than population size");
    }
    TContainer result;
#if __cplusplus >= 201703L
    std::sample(population.begin(),
                population.end(),
                std::back_inserter(result),
                k,
                engine_);
#else
    TContainer shuffled_population = population;
    this->shuffle(
        shuffled_population);  // 使用自身的shuffle方法/Use own shuffle method
    std::copy_n(shuffled_population.begin(), k, std::back_inserter(result));
#endif
    return result;
  }
 
  template<typename TContainer>
  TContainer generate(std::size_t n,
                      typename TContainer::value_type min,
                      typename TContainer::value_type max)
  {
    TContainer result;
    result.reserve(n);
    for (std::size_t i = 0; i < n; ++i) {
      result.push_back(random(min, max));
    }
    return result;
  }
 
private:
  std::mt19937 engine_;
};
 
inline int randint(int a, int b)
{
  return random_t::instance().randint(a, b);
}
 
template<typename T>
inline T random(T a, T b)
{
  return random_t::instance().random(a, b);
}
 
template<typename T>
inline T random()
{
  if constexpr (std::is_floating_point_v<T>) {
    return random_t::instance().random<T>(0, 1);
  } else if constexpr (std::is_integral_v<T>) {
    return random_t::instance().random<T>(0, std::numeric_limits<T>::max());
  } else {
    static_assert(std::is_floating_point_v<T> || std::is_integral_v<T>,
                  "random<T>() 仅支持浮点和整数类型/only supports floating "
                  "point and integral types");
    return T {};  // 这行代码永远不会执行，只是为了避免编译错误/This line will
                  // never execute, just to avoid compile error
  }
}
 
template<typename T>
inline T uniform(T a, T b)
{
  return random_t::instance().uniform(a, b);
}
 
template<typename T>
inline T gauss(T mu, T sigma)
{
  return random_t::instance().gauss(mu, sigma);
}
 
template<typename T>
inline T choice(const std::vector<T>& vec)
{
  return random_t::instance().choice(vec);
}
 
template<typename T>
inline std::vector<T> choice_n(const std::vector<T>& vec, size_t n)
{
  return random_t::instance().sample(vec, n);
}
 
template<typename T>
inline std::vector<T> sample(const std::vector<T>& population, size_t k)
{
  return random_t::instance().sample(population, k);
}
 
template<typename TContainer>
inline typename TContainer::value_type choice(const TContainer& container)
{
  static_assert(
      toolbox::traits::is_iterable_v<TContainer>,
      "choice<TContainer> 仅支持可迭代容器/only supports iterable containers");
  return random_t::instance().choice_general(container);
}
 
template<typename TContainer>
inline TContainer choice_n(const TContainer& container, size_t n)
{
  static_assert(toolbox::traits::is_iterable_v<TContainer>,
                "choice_n<TContainer> 仅支持可迭代容器/only supports iterable "
                "containers");
  return random_t::instance().sample(container, n);
}
 
template<typename TContainer>
inline TContainer sample(const TContainer& container, size_t n)
{
  static_assert(
      toolbox::traits::is_iterable_v<TContainer>,
      "sample<TContainer> 仅支持可迭代容器/only supports iterable containers");
  return random_t::instance().sample(container, n);
}
 
template<typename TContainer>
inline void shuffle(TContainer& container)
{
  random_t::instance().shuffle(container);
}
 
template<typename TContainer>
inline TContainer generate(std::size_t n,
                           typename TContainer::value_type min,
                           typename TContainer::value_type max)
{
  return random_t::instance().generate<TContainer>(n, min, max);
}
 
}  // namespace toolbox::utils