random.hh

Go to the documentation of this file.

#ifndef RANDOM_HH
#define RANDOM_HH
 
#include <random>
 
[[nodiscard]] inline auto& global_urng()
{
  static std::minstd_rand0 u;
  return u;
}
 
inline void randomize()
{
  static std::random_device rd;
  global_urng().seed(rd());
}
 
[[nodiscard]] inline bool random_bool()
{
  // Note: this is only 100% uniform if 'generator.max() -
  // generator().min() + 1' is even. This is the case for
  // std::minstd_rand0.
  auto& generator = global_urng();
  return generator() & 1;
}
 
[[nodiscard]] inline int random_int(int from, int thru)
{
  static std::uniform_int_distribution<int> d;
  using parm_t = decltype(d)::param_type;
  return d(global_urng(), parm_t{from, thru});
}
 
[[nodiscard]] inline float random_float(float from, float upto)
{
  static std::uniform_real_distribution<float> d;
  using parm_t = decltype(d)::param_type;
  return d(global_urng(), parm_t{from, upto});
}
 
[[nodiscard]] inline uint32_t random_32bit()
{
  static std::uniform_int_distribution<uint32_t> d;
  using parm_t = decltype(d)::param_type;
  return d(global_urng(), parm_t{0, 0xffffffff});
}
 
 
// Compile-time random numbers
 
// Constexpr "Permuted Congruential Generator" (PCG)
//   generated random numbers at compile-time
//   (or it shifts the problem to obtaining a random seed at compile time)
// Based upon:
//   C++ Weekly - Ep 44 - constexpr Compile Time Random
//   https://www.youtube.com/watch?v=rpn_5Mrrxf8
template<uint64_t SEED>
struct PCG
{
        constexpr uint32_t operator()()
        {
                // Advance internal state
                auto oldState = state;
                state = oldState * 6364136223846793005ULL + (SEED | 1);
 
                // Calculate output function (XSH RR), uses old state for max
                // ILP
                auto xorShifted = uint32_t(((oldState >> 18) ^ oldState) >> 27);
                auto rot = int(oldState >> 59);
                return (xorShifted >> rot) | (xorShifted << ((-rot) & 31));
        }
 
private:
        uint64_t state = SEED;
};
 
// Turns a random 32-bit integer into a random float in the range [0, 1).
[[nodiscard]] constexpr float getCanonicalFloat(uint32_t u)
{
        uint32_t b = 1 << 23;
        uint32_t m = b - 1;
        return float(u & m) / float(b);
}
 
#endif