Random.hpp

Go to the documentation of this file.

#pragma once
#ifndef ENIGMA_RANDOM_H
#define ENIGMA_RANDOM_H
 
#include <Core/Core.hpp>
#include <algorithm>
#include <random>
#include <climits>
//#include <execution> // std::for_each(std::execution::par, ...)
 
NS_ENIGMA_BEGIN
class Random final {
    ENIGMA_STATIC_CLASS(Random);
 
  public:
    template<typename T>
    static typename std::enable_if<std::is_floating_point<T>::value, T>::type
    Real(const T min, const T max) {
      ENIGMA_ASSERT(min < max, "min random value should be less than max value");
      std::uniform_real_distribution<T> dist(min, max);
      return dist(m_engine);
    }
 
    template<typename T>
    static typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value, T>::type
    Int(const T min, const T max) {
      ENIGMA_ASSERT(min < max, "min random value should be less than max value");
      std::uniform_int_distribution<T> dist(min, max);
      return dist(m_engine);
    }
 
    static bool Bool(const double p = 0.5) {
      std::bernoulli_distribution dist(p);
      return !!dist(m_engine);
    }
 
 
    static std::string Str(const std::size_t length) noexcept {
      static std::random_device seed{};
      static std::default_random_engine engine{seed()};
      static std::uniform_int_distribution<short> choice(0, 2);
      static std::uniform_int_distribution<int> lowercaseAlpha('a', 'z');
      static std::uniform_int_distribution<int> uppercaseAlpha('A', 'Z');
      static std::uniform_int_distribution<int> digits('0', '9');
 
      std::string str(length, '\000');
      for (char& c: str) {
        switch (choice(engine)) {
          case 0: // a-z
            c = lowercaseAlpha(engine);
            break;
          case 1: // A-Z
            c = uppercaseAlpha(engine);
            break;
          case 2: // 0-9
            c = digits(engine);
            break;
          default:
            break;
        }
      }
      return str;
    }
 
    static std::vector<byte> Bytes(const std::size_t length) noexcept {
      std::vector<byte> bytes(length);
#ifndef _MSC_VER
      using random_bytes_engine = std::independent_bits_engine<std::default_random_engine, CHAR_BIT, byte>;
      static random_bytes_engine gen{m_engine};
      std::generate(bytes.begin(), bytes.end(), std::ref(gen));
#else
      // MSVC's std::independent_bits_engine doesn't take std::uint8_t
      std::uniform_int_distribution<std::uint16_t> dist{static_cast<std::uint16_t>(std::numeric_limits<byte>::min()), static_cast<std::uint16_t>(std::numeric_limits<byte>::max())};
      std::generate(bytes.begin(), bytes.end(), [&]() -> byte {
        return dist(m_engine);
      });
#endif
      return bytes;
    }
 
 
    static void Reseed() {
      m_engine.seed(m_seed());
    }
 
    static std::default_random_engine& GetEngine() noexcept {
      return m_engine;
    }
 
  private:
    inline static std::random_device m_seed{};
    inline static std::default_random_engine m_engine{m_seed()};
};
NS_ENIGMA_END
 
#endif // !ENIGMA_RANDOM_H