random.h

Go to the documentation of this file.

 
#if !defined(VITA_RANDOM_H)
#define      VITA_RANDOM_H
 
#include <cstdlib>
#include <random>
 
#include "kernel/common.h"
#include "kernel/range.h"
#include "utility/xoshiro256ss.h"
 
namespace vita::random
{
 
enum class distribution {uniform, normal};
 
using engine_t = vigna::xoshiro256ss;
 
extern engine_t engine;
 
template<class T> [[nodiscard]] T sup(T);
 
[[nodiscard]] unsigned ring(unsigned, unsigned, unsigned);
 
[[nodiscard]] bool boolean(double = 0.5);
 
void seed(unsigned);
void randomize();
 
template<class T>
T ephemeral(distribution d, T p1, T p2)
{
  switch (d)
  {
  case distribution::uniform:
    return between(p1, p2);
 
  case distribution::normal:
    return std::normal_distribution<T>(p1, p2)(engine);
  }
}
 
template<class T>
std::enable_if_t<std::is_floating_point_v<T>, T>
between(T min, T sup)
{
  Expects(min < sup);
 
  std::uniform_real_distribution<T> d(min, sup);
  return d(engine);
}
 
template<class T>
std::enable_if_t<std::is_integral_v<T>, T>
between(T min, T sup)
{
  Expects(min < sup);
 
  std::uniform_int_distribution<T> d(min, sup - 1);
  return d(engine);
}
 
template<class T>
std::enable_if_t<std::is_enum_v<T>, T>
between(T min, T sup)
{
  Expects(min < sup);
 
  return static_cast<T>(between<std::underlying_type_t<T>>(min, sup));
}
 
template<class T>
T in(range_t<T> r)
{
  return between(r.first, r.second);
}
 
template<class T>
T sup(T sup)
{
  return between(static_cast<T>(0), sup);
}
 
template<class C>
const typename C::value_type &element(const C &c)
{
  Expects(c.size());
 
  return *std::next(
    c.begin(),
    static_cast<typename C::difference_type>(sup(c.size())));
}
 
template<class C>
typename C::value_type &element(C &c)
{
  Expects(c.size());
 
  return *std::next(
    c.begin(),
    static_cast<typename C::difference_type>(sup(c.size())));
}
 
inline bool boolean(double p)
{
  Expects(0.0 <= p);
  Expects(p <= 1.0);
 
  std::bernoulli_distribution d(p);
  return d(engine);
 
  //return between<double>(0, 1) < p;
}
 
}  // namespace vita::random
 
#endif  // include guard