ge211_random.hxx

#pragma once
 
#include "ge211_error.hxx"
#include "ge211_if_cpp.hxx"
#include "ge211_forward.hxx"
#include "ge211_type_traits.hxx"
 
#include <cmath>
#include <cstdint>
#include <limits>
#include <memory>
#include <random>
#include <type_traits>
 
namespace ge211 {
namespace detail {
namespace random {
 
using Generator = std::mt19937_64;
 
Generator
construct_generator();
 
template <typename T>
T
bound_between(T value, T lo, T hi)
{
    return std::max(lo, std::min(hi, value));
}
 
template <typename RESULT_TYPE>
struct Random_engine
{
    using result_type = RESULT_TYPE;
 
    virtual result_type next() = 0;
 
    virtual result_type next_between(result_type, result_type) = 0;
 
    virtual ~Random_engine() = default;
};
 
template <typename RESULT_TYPE, typename ENABLE = void>
struct Distribution
{
    struct
    {
        RESULT_TYPE contents;
    } error = "ge211::Random_source<RESULT_TYPE> requires "
              "RESULT_TYPE to be a built-in arithmetic type like int "
              "or double.";
};
 
template <typename RESULT_TYPE>
class Distribution<
        RESULT_TYPE,
        std::enable_if_t<Is_Integral<RESULT_TYPE>>
>
{
public:
    using result_type = RESULT_TYPE;
 
private:
    using impl_type = std::uniform_int_distribution<result_type>;
    impl_type impl_;
 
public:
    Distribution(result_type lo, result_type hi)
            : impl_{lo, hi}
    { }
 
    explicit Distribution(result_type end)
            : impl_{0, end - 1}
    { }
 
    result_type operator()(Generator &gen)
    {
        return impl_(gen);
    }
};
 
 
template <typename RESULT_TYPE>
class Distribution<
        RESULT_TYPE,
        std::enable_if_t<Is_Floating_Point<RESULT_TYPE>>>
{
public:
    using result_type = RESULT_TYPE;
 
private:
    using impl_type = std::uniform_real_distribution<result_type>;
    impl_type impl_;
 
public:
    Distribution(result_type lo, result_type hi)
            : impl_{lo, hi}
    { }
 
    result_type operator()(Generator &gen)
    {
        return impl_(gen);
    }
};
 
template <typename RESULT_TYPE>
class Pseudo_random_engine
        : public Random_engine<RESULT_TYPE>
{
public:
    using result_type = RESULT_TYPE;
 
    template <typename... Args>
    Pseudo_random_engine(Args&&... args);
 
    result_type next() override;
 
    result_type next_between(result_type, result_type) override;
 
private:
    Distribution<result_type> distribution_;
    Generator generator_;
};
 
template <>
class Pseudo_random_engine<bool>
        : public Random_engine<bool>
{
public:
    explicit Pseudo_random_engine(double p_true);
 
    bool next() override;
 
    bool next_between(bool, bool) override;
 
private:
    double probability_;
    Distribution<double> distribution_;
    Generator generator_;
};
 
template <typename RESULT_TYPE>
class Stub_random_engine
        : public Random_engine<RESULT_TYPE>
{
public:
    using result_type = RESULT_TYPE;
    using container_type = std::vector<RESULT_TYPE>;
    using iterator_type = typename container_type::const_iterator;
 
    // PRECONDITION: !container.empty()
    Stub_random_engine(container_type&& container);
 
    result_type next() override;
 
    result_type next_between(result_type, result_type) override;
 
private:
    container_type container_;
    iterator_type next_;
};
 
}  // end namespace random
}  // end namespace detail
 
class unbounded_type
{ };
 
constexpr unbounded_type const unbounded { };
 
template <typename RESULT_TYPE>
class Random_source
{
public:
    using result_type = RESULT_TYPE;
 
    IF_COMPILER(DECLARE_IF(!Is_Same<result_type, bool>))
    Random_source(result_type lo, result_type hi);
 
 
    IF_COMPILER(DECLARE_IF(
            Is_Integral<result_type> &&
            !Is_Same<result_type, bool>))
    explicit Random_source(result_type limit);
 
 
    IF_COMPILER(DECLARE_IF(Is_Same<result_type, bool>))
    explicit Random_source(double p_true);
 
 
    IF_COMPILER(DECLARE_IF(!Is_Same<result_type, bool>))
    explicit Random_source(unbounded_type);
 
 
    result_type next()
    {
        return engine_->next();
    }
 
    result_type operator()()
    {
        return next();
    }
 
 
    IF_COMPILER(DECLARE_IF(!Is_Same<result_type, bool>))
    result_type next_between(result_type lo, result_type hi)
    {
        return engine_->next_between(lo, hi);
    }
 
    IF_COMPILER(DECLARE_IF(!Is_Same<result_type, bool>))
    result_type operator()(result_type lo, result_type hi)
    {
        return next_between(lo, hi);
    }
 
    void stub_with(std::initializer_list<result_type> values);
 
 
    void stub_with(std::vector<result_type> values);
 
 
    void stub_with(result_type value);
 
 
    IF_COMPILER(DECLARE_IF(!Is_Same<result_type, bool>))
    static result_type bound_between(
            result_type value, result_type lo, result_type hi);
 
    Random_source(Random_source&& other) = delete;
 
    Random_source& operator=(Random_source&& other) = delete;
 
private:
    using Engine = detail::random::Random_engine<result_type>;
    using Prng = detail::random::Pseudo_random_engine<result_type>;
    using Stub = detail::random::Stub_random_engine<result_type>;
 
    std::unique_ptr<Engine> engine_;
};
 
 
//
// IMPLEMENTATIONS
//
 
namespace detail {
namespace random {
 
using std::begin;
using std::end;
 
template <typename RESULT_TYPE>
template <typename... Args>
Pseudo_random_engine<RESULT_TYPE>::Pseudo_random_engine(Args&&... args)
        : distribution_{std::forward<Args>(args)...},
          generator_{construct_generator()}
{ }
 
template <typename RESULT_TYPE>
RESULT_TYPE
Pseudo_random_engine<RESULT_TYPE>::next()
{
    return distribution_(generator_);
}
 
template <typename RESULT_TYPE>
RESULT_TYPE
Pseudo_random_engine<RESULT_TYPE>::next_between(result_type lo, result_type hi)
{
    return Distribution<result_type>{lo, hi}(generator_);
}
 
template <typename RESULT_TYPE>
Stub_random_engine<RESULT_TYPE>::Stub_random_engine(container_type&& container)
        : container_(std::move(container)),
          next_(begin(container_))
{
    if (next_ == end(container_)) {
        throw ge211::Client_logic_error{
                "Random_source: cannot stub with empty container"};
    }
}
 
template <typename RESULT_TYPE>
RESULT_TYPE
Stub_random_engine<RESULT_TYPE>::next()
{
    result_type result = *next_++;
    if (next_ == end(container_)) next_ = begin(container_);
    return result;
}
 
template <typename RESULT_TYPE>
RESULT_TYPE
Stub_random_engine<RESULT_TYPE>::next_between(result_type lo, result_type hi)
{
    return bound_between<result_type>(next(), lo, hi);
}
 
}  // end namespace random
}  // end namespace detail
 
template <typename RESULT_TYPE>
IF_COMPILER(DEFINE_IF)
Random_source<RESULT_TYPE>::Random_source(result_type lo, result_type hi)
        : engine_{std::make_unique<Prng>(lo, hi)}
{ }
 
template <typename RESULT_TYPE>
IF_COMPILER(DEFINE_IF)
Random_source<RESULT_TYPE>::Random_source(result_type limit)
        : engine_{std::make_unique<Prng>(limit)}
{ }
 
template <typename RESULT_TYPE>
IF_COMPILER(DEFINE_IF)
Random_source<RESULT_TYPE>::Random_source(double p_true)
        : engine_{std::make_unique<Prng>(p_true)}
{ }
 
template <typename RESULT_TYPE>
IF_COMPILER(DEFINE_IF)
Random_source<RESULT_TYPE>::Random_source(unbounded_type)
        : Random_source{0, std::numeric_limits<result_type>::max()}
{ }
 
template <typename RESULT_TYPE>
void
Random_source<RESULT_TYPE>::stub_with(std::vector<result_type> values)
{
    engine_ = std::make_unique<Stub>(std::move(values));
}
 
template <typename RESULT_TYPE>
void
Random_source<RESULT_TYPE>::stub_with(std::initializer_list<result_type> values)
{
    stub_with(std::vector<result_type>(values));
}
 
template <typename RESULT_TYPE>
void
Random_source<RESULT_TYPE>::stub_with(result_type value)
{
    stub_with({value});
}
 
template <typename RESULT_TYPE>
IF_COMPILER(DEFINE_IF)
RESULT_TYPE
Random_source<RESULT_TYPE>::bound_between(
        result_type value,
        result_type lo,
        result_type hi)
{
    return detail::random::bound_between<result_type>(value, lo, hi);
}
 
}  // end namespace ge211