qbpp_misc.hpp

Go to the documentation of this file.

 
#ifndef QBPP_MISC_HPP
#define QBPP_MISC_HPP
 
#include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <random>
#include <vector>
 
#include "qbpp.hpp"
 
namespace qbpp {
 
namespace misc {
 
class RandomGenerator {
  std::mt19937_64 mt;
 
  RandomGenerator() : mt(std::random_device{}()) {}
 
  RandomGenerator(const RandomGenerator &) = delete;
 
  RandomGenerator &operator=(const RandomGenerator &) = delete;
 
  static RandomGenerator &get_instance() {
    static RandomGenerator instance;
    return instance;
  }
 
 public:
  static void set_seed(uint32_t seed = 1) { get_instance().mt.seed(seed); }
 
  static void rd_seed() { get_instance().mt.seed(std::random_device{}()); }
 
  static uint64_t gen() { return static_cast<uint64_t>(get_instance().mt()); }
 
  template <typename T>
  static typename std::enable_if<std::is_integral<T>::value, T>::type gen(T n) {
    std::uniform_int_distribution<qbpp::vindex_t> dist(0, n - 1);
    return dist(get_instance().mt);
  }
 
  static qbpp::cpp_int gen(const qbpp::cpp_int &n) {
    qbpp::cpp_int val;
    do {
      val = (val << 64) + gen();
    } while (val < (n << 32));
    return val % n;
  }
 
  static double gen_double() {
    std::uniform_real_distribution<double> dist(0.0, 1.0);
    return dist(get_instance().mt);
  }
 
  static std::mt19937_64 &get_mt() { return get_instance().mt; }
};
 
 
class RandomPermutation {
  const uint32_t size_;
 
  std::vector<uint32_t> perm;
 
  uint32_t index = 0;
 
 public:
  explicit RandomPermutation(uint32_t size) : size_(size), perm(size) {
    std::iota(perm.begin(), perm.end(), 0);
  }
 
  uint32_t get() {
    if (index == 0) {
      std::shuffle(perm.begin(), perm.end(), RandomGenerator::get_mt());
    }
    uint32_t current = index;
    index = (index + 1) % size_;
    return perm[current];
  }
};
 
struct PcloseDeleter {
  void operator()(FILE *file) const {
    if (file) pclose(file);
  }
};
 
}  
}  
 
#endif