Random.h

#pragma once

#include <stdexcept>
#include <random>
#include <type_traits>

#include <lazarus/common.h>

namespace lz
{
class Random
{
public:
    static void seed();

    static void seed(unsigned seed);

    template <typename T, typename U,
              typename std::enable_if_t<
                (std::is_integral<T>::value || std::is_unsigned<T>::value)
                && (std::is_integral<U>::value || std::is_unsigned<U>::value)
                >* = nullptr>
    static typename std::common_type<T, U>::type range(T a, U b)
    {
        typedef typename std::common_type<T, U>::type common_type;
        auto _a = static_cast<common_type>(a);
        auto _b = static_cast<common_type>(b);
        if (_a > _b)
            std::swap(_a, _b);
        return std::uniform_int_distribution<common_type>(_a, _b)(generator);
    }

    template <typename T, typename U,
              typename std::enable_if_t<
                std::is_floating_point<T>::value || std::is_floating_point<U>::value
                >* = nullptr>
    static typename std::common_type<T, U>::type range(T a, U b)
    {
        typedef typename std::common_type<T, U>::type common_type;
        auto _a = static_cast<common_type>(a);
        auto _b = static_cast<common_type>(b);
        if (_a > _b)
            std::swap(_a, _b);
        return std::uniform_real_distribution<common_type>(_a, _b)(generator);
    }

    static ulong roll(unsigned sides=6, unsigned times=1);

    static bool oneIn(unsigned n);

    static double normal(double mean, double stdev);

    template <typename C, typename T = typename C::value_type>
    static T& choice(C& container);

private:
    static std::mt19937 generator;
};

template <typename C, typename T>
T& Random::choice(C& container)
{
    // Use size() instead of empty() to make conditions less restrictive
    size_t size = container.size();
    if (size == 0)
        throw __lz::LazarusException("Container is empty");
    
    size_t idx = Random::range(0, size - 1);
    return container[idx];
}

}  // namespace lz