libcruft-util/random.hpp

154 lines
4.3 KiB
C++

/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Copyright 2016-2017 Danny Robson <danny@nerdcruft.net>
*/
#ifndef CRUFT_UTIL_RANDOM_HPP
#define CRUFT_UTIL_RANDOM_HPP
#include "coord/traits.hpp"
#include <algorithm>
#include <array>
#include <random>
#include <limits>
#include <type_traits>
namespace util::random {
template <typename T>
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;
///////////////////////////////////////////////////////////////////////////
/// return correctly initialised 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;
}
///////////////////////////////////////////////////////////////////////////
/// select a value uniformly from the range [lo, hi)
template <typename T>
std::enable_if_t<std::is_floating_point_v<T>,T>
uniform (T lo, T hi)
{
return std::uniform_real_distribution<T> { lo, hi } (generator ());
}
template <typename T>
std::enable_if_t<std::is_floating_point_v<T>,T>
uniform (void)
{
return uniform<T> (0, 1);
}
///------------------------------------------------------------------------
/// select a value uniformly from the range [lo, hi) using a supplied
/// generator
template <
typename T,
typename GeneratorT,
typename = std::enable_if_t<std::is_integral_v<T>>
>
T
uniform (T lo, T hi, GeneratorT &&gen)
{
return std::uniform_int_distribution<T> { lo, hi } (gen);
}
///------------------------------------------------------------------------
/// select a value uniformly from the range [lo, hi)
template <typename T>
std::enable_if_t<std::is_integral_v<T>,T>
uniform (T lo, T hi)
{
return uniform (lo, hi, generator ());
}
//-------------------------------------------------------------------------
template <typename T>
std::enable_if_t<std::is_integral_v<T>,T>
uniform (void)
{
return uniform (
std::numeric_limits<T>::min (),
std::numeric_limits<T>::max ()
);
}
//-------------------------------------------------------------------------
template <
typename T,
typename = std::enable_if_t<
is_coord_v<T> && std::is_floating_point_v<typename T::value_type>
>
>
T
uniform (void)
{
T res {};
std::fill (res.begin (), res.end (), uniform<typename T::value_type> ());
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 ())];
}
};
#endif