libcruft-util/random.hpp

/*
 * 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/.
 *
 * Copyright 2016-2018 Danny Robson <danny@nerdcruft.net>
 */

#pragma once

#include "coord/traits.hpp"

#include <algorithm>
#include <array>
#include <random>
#include <limits>
#include <type_traits>


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.
    template <
        typename ValueT,
        typename = std::enable_if_t<
            is_coord_v<ValueT> && std::is_floating_point_v<typename ValueT::value_type>
        >
    >
    ValueT
    uniform (void)
    {
        ValueT res {};
        std::fill (res.begin (), res.end (), uniform<typename ValueT::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 ())];
    }
};