libcruft-util/random.hpp

183 lines
5.6 KiB
C++
Raw Normal View History

2011-09-13 15:13:55 +10:00
/*
2018-08-04 15:14:06 +10:00
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
2011-09-13 15:13:55 +10:00
*
* Copyright 2016-2018 Danny Robson <danny@nerdcruft.net>
2011-09-13 15:13:55 +10:00
*/
#pragma once
2011-09-13 15:13:55 +10:00
#include "coord/traits.hpp"
#include <algorithm>
#include <array>
#include <random>
#include <limits>
#include <type_traits>
2011-09-13 15:13:55 +10:00
namespace cruft::random {
/// A trait describing the internal state size of a given Generator.
///
/// The structure must be specialised.
///
/// \tparam GeneratorT The generator to query
template <typename GeneratorT>
struct state_size;
//-------------------------------------------------------------------------
template <
class UIntType,
size_t w, size_t n, size_t m, size_t r,
UIntType a, size_t u, UIntType d, size_t s,
UIntType b, size_t t,
UIntType c, size_t l, UIntType f
> struct state_size<std::mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>> {
static constexpr auto value = n * sizeof (UIntType);
};
//-------------------------------------------------------------------------
template <typename UIntType, UIntType a, UIntType c, UIntType m>
struct state_size<std::linear_congruential_engine<UIntType,a,c,m>> {
static constexpr auto value = sizeof (UIntType);
};
//-------------------------------------------------------------------------
template <typename T>
constexpr auto state_size_v = state_size<T>::value;
///////////////////////////////////////////////////////////////////////////
/// Returns a correctly pre-initialised reference to a thread-local
/// generator of an unspecified (but not entirely useless) type.
///
/// ie, not LCG.
inline auto&
generator (void)
{
using generator_t = std::default_random_engine;
static thread_local generator_t gen = [] () {
std::array<int,state_size_v<generator_t> / 4> seed;
std::generate (seed.begin (), seed.end (), std::random_device ());
std::seed_seq seq (seed.begin (), seed.end ());
return generator_t (seq);
} ();
return gen;
}
///////////////////////////////////////////////////////////////////////////
/// A convenience typedef that selects between
/// std::uniform_real_distribution and std::uniform_int_distribution
/// depending on the supplied value type.
template <typename ValueT>
using uniform_distribution = std::conditional_t<
std::is_floating_point<ValueT>::value,
std::uniform_real_distribution<ValueT>,
std::uniform_int_distribution<ValueT>
>;
///////////////////////////////////////////////////////////////////////////
/// Returns a value chosen uniformly at random the supplied range.
///
/// This is primarily a convenience helper around the uniform_distribution
/// type.
template <typename ValueT, typename GeneratorT>
decltype(auto)
uniform (ValueT lo, ValueT hi, GeneratorT &&gen)
{
return uniform_distribution<ValueT> { lo, hi } (
std::forward<GeneratorT> (gen)
);
}
///------------------------------------------------------------------------
/// Return a value uniformly random chosen value between lo and hi.
///
/// Interval bounds are treated as per the standard Generator
/// implementations; ie, inclusive for integers, exclusive upper for reals.
template <typename T>
decltype(auto)
uniform (T lo, T hi)
{
return uniform<T> (lo, hi, generator ());
}
///------------------------------------------------------------------------
/// Return a uniformly random value chosen on the interval [0,1)
template <
typename ValueT,
typename GeneratorT,
typename = std::enable_if_t<std::is_floating_point_v<ValueT>>
>
decltype(auto)
uniform (GeneratorT &&gen)
{
return uniform<ValueT> (ValueT{0}, ValueT{1}, std::forward<GeneratorT> (gen));
}
///------------------------------------------------------------------------
/// Return a uniformly random chosen value on the interval [0.f, 1.f)
template <
typename ValueT,
typename = std::enable_if_t<std::is_floating_point_v<ValueT>>
>
decltype(auto)
uniform (void)
{
return uniform<ValueT> (ValueT{0}, ValueT{1}, generator ());
}
///------------------------------------------------------------------------
/// Return a uniformly random chosen value on the interval [0, 1]
template <typename T>
std::enable_if_t<std::is_integral_v<T>,T>
uniform (void)
{
return uniform<T> (
std::numeric_limits<T>::min (),
std::numeric_limits<T>::max ()
);
}
///------------------------------------------------------------------------
/// Returns a uniformly random initialised coordinate type by value.
2018-05-30 14:33:31 +10:00
template <
typename ValueT,
2018-05-30 14:33:31 +10:00
typename = std::enable_if_t<
is_coord_v<ValueT> && std::is_floating_point_v<typename ValueT::value_type>
2018-05-30 14:33:31 +10:00
>
>
ValueT
2018-05-30 14:33:31 +10:00
uniform (void)
{
ValueT res {};
std::fill (res.begin (), res.end (), uniform<typename ValueT::value_type> ());
2018-05-30 14:33:31 +10:00
return res;
}
///////////////////////////////////////////////////////////////////////////
/// choose a value at random from an array
template <typename T, size_t N>
T&
choose (T (&t)[N])
{
std::uniform_int_distribution<size_t> dist (0, N - 1);
return t[dist (generator ())];
}
};