random.hpp

/*
______  ___   _   _______ ________  __
| ___ \/ _ \ | \ | |  _  \  _  |  \/  | Random for modern C++
| |_/ / /_\ \|  \| | | | | | | | .  . |
|    /|  _  || . ` | | | | | | | |\/| | version 1.4.0
| |\ \| | | || |\  | |/ /\ \_/ / |  | |
\_| \_\_| |_/\_| \_/___/  \___/\_|  |_/ https://github.com/effolkronium/random
 
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
Copyright (c) 2017-2021 effolkronium
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files( the "Software" ), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
 
#ifndef EFFOLKRONIUM_RANDOM_HPP
#define EFFOLKRONIUM_RANDOM_HPP
 
#include <random>
#include <chrono> // timed seed
#include <type_traits>
#include <cassert>
#include <initializer_list>
#include <utility> // std::forward, std::declval
#include <algorithm> // std::shuffle, std::next, std::distance
#include <iterator> // std::begin, std::end, std::iterator_traits
#include <limits> // std::numeric_limits
#include <ostream>
#include <istream>
 
namespace effolkronium {
 
    namespace details {
        struct common{ }; 
 
        template<typename T>
        struct is_uniform_int {
            static constexpr bool value =
                   std::is_same<T,              short>::value
                || std::is_same<T,                int>::value
                || std::is_same<T,               long>::value
                || std::is_same<T,          long long>::value
                || std::is_same<T,     unsigned short>::value
                || std::is_same<T,       unsigned int>::value
                || std::is_same<T,      unsigned long>::value
                || std::is_same<T, unsigned long long>::value;
        };
 
        template<typename T>
        struct is_uniform_real {
            static constexpr bool value =
                   std::is_same<T,       float>::value
                || std::is_same<T,      double>::value
                || std::is_same<T, long double>::value;
        };
 
        template<typename T>
        struct is_byte {
            static constexpr bool value =
                   std::is_same<T,   signed char>::value
                || std::is_same<T, unsigned char>::value;
        };
 
        template<typename T>
        struct is_supported_number {
            static constexpr bool value =
                   is_byte        <T>::value
                || is_uniform_real<T>::value
                || is_uniform_int <T>::value;
        };
 
        template<typename T>
        struct is_supported_character {
            static constexpr bool value =
                   std::is_same<T, char>::value
                || std::is_same<T, wchar_t>::value
                || std::is_same<T, char16_t>::value
                || std::is_same<T, char32_t>::value;
        };
 
        template<typename T>
        struct is_iterator {
        private:
            static char test( ... );
 
            template <typename U,
                typename = typename std::iterator_traits<U>::difference_type,
                typename = typename std::iterator_traits<U>::pointer,
                typename = typename std::iterator_traits<U>::reference,
                typename = typename std::iterator_traits<U>::value_type,
                typename = typename std::iterator_traits<U>::iterator_category
            > static long test( U&& );
        public:
            static constexpr bool value = std::is_same<
                decltype( test( std::declval<T>( ) ) ), long>::value;
        };
 
        template <typename T>
        class has_reserve
        {
        private:
            template <typename C>
            static char test(...);
 
            template <typename C>
            static long test(decltype(&C::reserve));
        public:
            static constexpr bool value = std::is_same<
                decltype(test<T>(0)), long>::value;
        };
 
        template <typename T>
        class has_insert
        {
        private:
            template <typename C>
            static char test(...);
 
            template <typename C>
            static long test(decltype(&C::insert));
        public:
            static constexpr bool value = std::is_same<
                decltype(test<T>(0)), long>::value;
        };
 
    } // namespace details
 
    struct seeder_default {
        std::seed_seq& operator() ( ) {
            // MinGW issue, std::random_device returns constant value
            // Use std::seed_seq with additional seed from C++ chrono
            return seed_seq;
        }
    private:
        std::seed_seq seed_seq{ {
                static_cast<std::uintmax_t>( std::random_device{ }( ) ),
                static_cast<std::uintmax_t>( std::chrono::steady_clock::now( )
                                             .time_since_epoch( ).count( ) ),
        } };
    };
 
    template<
        typename Engine,
        typename Seeder = seeder_default,
        template<typename> class IntegerDist = std::uniform_int_distribution,
        template<typename> class RealDist = std::uniform_real_distribution,
        typename BoolDist = std::bernoulli_distribution
    >
    class basic_random_static {
    public:
        basic_random_static( ) = delete;
 
        using engine_type = Engine;
 
        using seeder_type = Seeder;
 
        template<typename T>
        using integer_dist_t = IntegerDist<T>;
 
        template<typename T>
        using real_dist_t = RealDist<T>;
 
        using bool_dist_t = BoolDist;
 
        using common = details::common;
 
        static constexpr typename Engine::result_type min( ) {
            return Engine::min( );
        }
 
        static constexpr typename Engine::result_type max( ) {
            return Engine::max( );
        }
 
        static void discard( const unsigned long long z ) {
            engine_instance( ).discard( z );
        }
 
        static void reseed( ) {
            Seeder seeder;
            seed( seeder( ) );
        }
 
        static void seed( const typename Engine::result_type value =
                          Engine::default_seed ) {
            engine_instance( ).seed( value );
        }
 
        template<typename Sseq>
        static void seed( Sseq& seq ) {
            engine_instance( ).seed( seq );
        }
 
        static typename Engine::result_type get( ) {
            return engine_instance( )( );
        }
 
        static bool is_equal( const Engine& other ) {
            return engine_instance( ) == other;
        }
 
        template<typename CharT, typename Traits>
        static void serialize( std::basic_ostream<CharT, Traits>& ost ) {
            ost << engine_instance( );
        }
 
        template<typename CharT, typename Traits>
        static void deserialize( std::basic_istream<CharT, Traits>& ist ) {
            ist >> engine_instance( );
        }
 
        template<typename T>
        static typename std::enable_if<details::is_uniform_int<T>::value
            , T>::type get( T from = std::numeric_limits<T>::min( ),
                            T to = std::numeric_limits<T>::max( ) ) {
            if( from < to ) // Allow range from higher to lower
                return IntegerDist<T>{ from, to }( engine_instance( ) );
            return IntegerDist<T>{ to, from }( engine_instance( ) );
        }
 
        template<typename T>
        static typename std::enable_if<details::is_uniform_real<T>::value
            , T>::type get( T from = std::numeric_limits<T>::min( ),
                            T to = std::numeric_limits<T>::max( ) ) {
            if( from < to ) // Allow range from higher to lower
                return RealDist<T>{ from, to }( engine_instance( ) );
            return RealDist<T>{ to, from }( engine_instance( ) );
        }
 
        template<typename T>
        static typename std::enable_if<details::is_byte<T>::value
            , T>::type get( T from = std::numeric_limits<T>::min( ),
                            T to = std::numeric_limits<T>::max( ) ) {
            // Choose between short and unsigned short for byte conversion
            using short_t = typename std::conditional<std::is_signed<T>::value,
                short, unsigned short>::type;
 
            return static_cast<T>( get<short_t>( from, to ) );
        }
 
        template<
            typename Key,
            typename A,
            typename B, 
            typename C = typename std::common_type<A, B>::type
        >
        static typename std::enable_if<
               std::is_same<Key, common>::value
            && details::is_supported_number<A>::value
            && details::is_supported_number<B>::value
            // Prevent implicit type conversion from singed to unsigned types
            && std::is_signed<A>::value != std::is_unsigned<B>::value
            , C>::type get( A from = std::numeric_limits<A>::min( ),
                            B to = std::numeric_limits<B>::max( ) ) {
            return get( static_cast<C>( from ), static_cast<C>( to ) );
        }
 
        template<typename T>
        static typename std::enable_if<details::is_supported_character<T>::value
            , T>::type get(T from = std::numeric_limits<T>::min(),
                T to = std::numeric_limits<T>::max()) {
            if (from < to) // Allow range from higher to lower
                return static_cast<T>(IntegerDist<std::int64_t>{ static_cast<std::int64_t>(from), static_cast<std::int64_t>(to) }(engine_instance()));
            return static_cast<T>(IntegerDist<std::int64_t>{ static_cast<std::int64_t>(to), static_cast<std::int64_t>(from) }(engine_instance()));
        }
 
        template<typename T>
        static typename std::enable_if<std::is_same<T, bool>::value
            , bool>::type get( const double probability = 0.5 ) {
            assert( 0 <= probability && 1 >= probability ); // out of [0; 1] range
            return BoolDist{ probability }( engine_instance( ) );
        }
 
        template<typename T>
        static T get( std::initializer_list<T> init_list ) {
            assert( 0u != init_list.size( ) );
            return *get( init_list.begin( ), init_list.end( ) );
        }
 
        template<typename InputIt>
        static typename std::enable_if<details::is_iterator<InputIt>::value
            , InputIt>::type get( InputIt first, InputIt last ) {
            const auto size = std::distance( first, last );
            if( 0 == size ) return last;
            using diff_t = typename std::iterator_traits<InputIt>::difference_type;
            return std::next( first, get<diff_t>( 0, size - 1 ) );
        }
 
        template<typename Container>
        static auto get( Container& container ) -> 
            typename std::enable_if<details::is_iterator<
                decltype(std::begin(container))>::value
                , decltype(std::begin(container))
            >::type {
            return get( std::begin( container ), std::end( container ) );
        }
 
        template<template<typename...> class Container, typename A>
        static typename std::enable_if<
                details::has_reserve<Container<A>>::value
            , Container<A>>::type get(A from, A to, std::size_t size) {
            Container<A> container;
 
            container.reserve(size);
            for (std::size_t i = 0; i < size; ++i)
                container.insert(std::end(container), get(from, to));
 
            return container;
        }
 
        template<
            template<typename...> class Container,
            typename Key,
            typename A,
            typename B,
            typename C = typename std::common_type<A, B>::type>
        static typename std::enable_if<
                   std::is_same<Key, common>::value
                && details::has_reserve<Container<A>>::value
            , Container<C>>::type get(A start, B end, std::size_t size) {
            Container<C> container;
 
            container.reserve(size);
            for (std::size_t i = 0; i < size; ++i)
                container.insert(std::end(container), get<common>(start, end));
 
            return container;
        }
 
        template<template<typename...> class Container, typename A>
        static typename std::enable_if<
              !details::has_reserve<Container<A>>::value
            , Container<A>>::type get(A start, A end, std::size_t size) {
            Container<A> container;
 
            for (std::size_t i = 0; i < size; ++i)
                container.insert(std::end(container), get(start, end));
 
            return container;
        }
 
        template<
            template<typename...> class Container,
            typename Key,
            typename A,
            typename B,
            typename C = typename std::common_type<A, B>::type>
        static typename std::enable_if<
                 std::is_same<Key, common>::value
              && !details::has_reserve<Container<C>>::value
            , Container<C>>::type get(A start, B end, std::size_t size) {
            Container<C> container;
 
            for (std::size_t i = 0; i < size; ++i)
                container.insert(std::end(container), get<common>(start, end));
 
            return container;
        }
 
        template<template<typename AA, std::size_t NN, typename...> class Container, std::size_t N, typename A>
        static typename std::enable_if<
               !details::has_insert<Container<A, N>>::value
            , Container<A, N>>::type get(A start, A end) {
            Container<A, N> container = {{ 0 }};
 
            for (std::size_t i = 0; i < N; ++i)
                container[i] = get(start, end);
 
            return container;
        }
 
        template<
            template<typename AA, std::size_t NN, typename...> class Container,
            std::size_t N,
            typename Key,
            typename A,
            typename B,
            typename C = typename std::common_type<A, B>::type>
        static typename std::enable_if<
                  std::is_same<Key, common>::value
               && !details::has_insert<Container<C, N>>::value
            , Container<C, N>>::type get(A start, B end) {
            Container<C, N> container = {{ 0 }};
 
            for (std::size_t i = 0; i < N; ++i)
                container[i] = get<common>(start, end);
 
            return container;
        }
 
        template<typename T, std::size_t N>
        static T* get( T( &array )[ N ] ) {
            return std::addressof( array[ get<std::size_t>( 0, N - 1 ) ] );
        }
 
        template<typename Dist, typename... Args>
        static typename Dist::result_type get( Args&&... args ) {
            return Dist{ std::forward<Args>( args )... }( engine_instance( ) );
        }
 
        template<typename Dist>
        static typename Dist::result_type get( Dist& dist ) {
            return dist( engine_instance( ) );
        }
 
        template<typename RandomIt>
        static void shuffle( RandomIt first, RandomIt last ) {
            std::shuffle( first, last, engine_instance( ) );
        }
 
        template<typename Container>
        static void shuffle( Container& container ) {
            shuffle( std::begin( container ), std::end( container ) );
        }
 
        static Engine get_engine( ) {
            return engine_instance( );
        }
 
        static Engine& engine() {
            return engine_instance();
        }
    protected:
        static Engine& engine_instance( ) {
            static Engine engine{ Seeder{ }( ) };
            return engine;
        }
    };
 
    template<
        typename Engine,
        typename Seeder = seeder_default,
        template<typename> class IntegerDist = std::uniform_int_distribution,
        template<typename> class RealDist = std::uniform_real_distribution,
        typename BoolDist = std::bernoulli_distribution
    >
    class basic_random_thread_local {
    public:
        basic_random_thread_local( ) = delete;
 
        using engine_type = Engine;
 
        using seeder_type = Seeder;
 
        template<typename T>
        using integer_dist_t = IntegerDist<T>;
 
        template<typename T>
        using real_dist_t = RealDist<T>;
 
        using bool_dist_t = BoolDist;
 
        using common = details::common;
 
        static constexpr typename Engine::result_type min( ) {
            return Engine::min( );
        }
 
        static constexpr typename Engine::result_type max( ) {
            return Engine::max( );
        }
 
        static void discard( const unsigned long long z ) {
            engine_instance( ).discard( z );
        }
 
        static void reseed( ) {
            Seeder seeder;
            seed( seeder( ) );
        }
 
        static void seed( const typename Engine::result_type value =
                          Engine::default_seed ) {
            engine_instance( ).seed( value );
        }
 
        template<typename Sseq>
        static void seed( Sseq& seq ) {
            engine_instance( ).seed( seq );
        }
 
        static typename Engine::result_type get( ) {
            return engine_instance( )( );
        }
 
        static bool is_equal( const Engine& other ) {
            return engine_instance( ) == other;
        }
 
        template<typename CharT, typename Traits>
        static void serialize( std::basic_ostream<CharT, Traits>& ost ) {
            ost << engine_instance( );
        }
 
        template<typename CharT, typename Traits>
        static void deserialize( std::basic_istream<CharT, Traits>& ist ) {
            ist >> engine_instance( );
        }
 
        template<typename T>
        static typename std::enable_if<details::is_uniform_int<T>::value
            , T>::type get( T from = std::numeric_limits<T>::min( ),
                            T to = std::numeric_limits<T>::max( ) ) {
            if( from < to ) // Allow range from higher to lower
                return IntegerDist<T>{ from, to }( engine_instance( ) );
            return IntegerDist<T>{ to, from }( engine_instance( ) );
        }
 
        template<typename T>
        static typename std::enable_if<details::is_uniform_real<T>::value
            , T>::type get( T from = std::numeric_limits<T>::min( ),
                            T to = std::numeric_limits<T>::max( ) ) {
            if( from < to ) // Allow range from higher to lower
                return RealDist<T>{ from, to }( engine_instance( ) );
            return RealDist<T>{ to, from }( engine_instance( ) );
        }
 
        template<typename T>
        static typename std::enable_if<details::is_byte<T>::value
            , T>::type get( T from = std::numeric_limits<T>::min( ),
                            T to = std::numeric_limits<T>::max( ) ) {
            // Choose between short and unsigned short for byte conversion
            using short_t = typename std::conditional<std::is_signed<T>::value,
                short, unsigned short>::type;
 
            return static_cast<T>( get<short_t>( from, to ) );
        }
 
        template<
            typename Key,
            typename A,
            typename B, 
            typename C = typename std::common_type<A, B>::type
        >
        static typename std::enable_if<
               std::is_same<Key, common>::value
            && details::is_supported_number<A>::value
            && details::is_supported_number<B>::value
            // Prevent implicit type conversion from singed to unsigned types
            && std::is_signed<A>::value != std::is_unsigned<B>::value
            , C>::type get( A from = std::numeric_limits<A>::min( ),
                            B to = std::numeric_limits<B>::max( ) ) {
            return get( static_cast<C>( from ), static_cast<C>( to ) );
        }
 
        template<typename T>
        static typename std::enable_if<details::is_supported_character<T>::value
            , T>::type get(T from = std::numeric_limits<T>::min(),
                T to = std::numeric_limits<T>::max()) {
            if (from < to) // Allow range from higher to lower
                return static_cast<T>(IntegerDist<std::int64_t>{ static_cast<std::int64_t>(from), static_cast<std::int64_t>(to) }(engine_instance()));
            return static_cast<T>(IntegerDist<std::int64_t>{ static_cast<std::int64_t>(to), static_cast<std::int64_t>(from) }(engine_instance()));
        }
 
        template<typename T>
        static typename std::enable_if<std::is_same<T, bool>::value
            , bool>::type get( const double probability = 0.5 ) {
            assert( 0 <= probability && 1 >= probability ); // out of [0; 1] range
            return BoolDist{ probability }( engine_instance( ) );
        }
 
        template<typename T>
        static T get( std::initializer_list<T> init_list ) {
            assert( 0u != init_list.size( ) );
            return *get( init_list.begin( ), init_list.end( ) );
        }
 
        template<typename InputIt>
        static typename std::enable_if<details::is_iterator<InputIt>::value
            , InputIt>::type get( InputIt first, InputIt last ) {
            const auto size = std::distance( first, last );
            if( 0 == size ) return last;
            using diff_t = typename std::iterator_traits<InputIt>::difference_type;
            return std::next( first, get<diff_t>( 0, size - 1 ) );
        }
 
        template<typename Container>
        static auto get( Container& container ) -> 
            typename std::enable_if<details::is_iterator<
                decltype(std::begin(container))>::value
                , decltype(std::begin(container))
            >::type {
            return get( std::begin( container ), std::end( container ) );
        }
 
        template<template<typename...> class Container, typename A>
        static typename std::enable_if<
                details::has_reserve<Container<A>>::value
            , Container<A>>::type get(A from, A to, std::size_t size) {
            Container<A> container;
 
            container.reserve(size);
            for (std::size_t i = 0; i < size; ++i)
                container.insert(std::end(container), get(from, to));
 
            return container;
        }
 
        template<
            template<typename...> class Container,
            typename Key,
            typename A,
            typename B,
            typename C = typename std::common_type<A, B>::type>
        static typename std::enable_if<
                   std::is_same<Key, common>::value
                && details::has_reserve<Container<A>>::value
            , Container<C>>::type get(A start, B end, std::size_t size) {
            Container<C> container;
 
            container.reserve(size);
            for (std::size_t i = 0; i < size; ++i)
                container.insert(std::end(container), get<common>(start, end));
 
            return container;
        }
 
        template<template<typename...> class Container, typename A>
        static typename std::enable_if<
              !details::has_reserve<Container<A>>::value
            , Container<A>>::type get(A start, A end, std::size_t size) {
            Container<A> container;
 
            for (std::size_t i = 0; i < size; ++i)
                container.insert(std::end(container), get(start, end));
 
            return container;
        }
 
        template<
            template<typename...> class Container,
            typename Key,
            typename A,
            typename B,
            typename C = typename std::common_type<A, B>::type>
        static typename std::enable_if<
                 std::is_same<Key, common>::value
              && !details::has_reserve<Container<C>>::value
            , Container<C>>::type get(A start, B end, std::size_t size) {
            Container<C> container;
 
            for (std::size_t i = 0; i < size; ++i)
                container.insert(std::end(container), get<common>(start, end));
 
            return container;
        }
 
        template<template<typename AA, std::size_t NN, typename...> class Container, std::size_t N, typename A>
        static typename std::enable_if<
               !details::has_insert<Container<A, N>>::value
            , Container<A, N>>::type get(A start, A end) {
            Container<A, N> container = {{ 0 }};
 
            for (std::size_t i = 0; i < N; ++i)
                container[i] = get(start, end);
 
            return container;
        }
 
        template<
            template<typename AA, std::size_t NN, typename...> class Container,
            std::size_t N,
            typename Key,
            typename A,
            typename B,
            typename C = typename std::common_type<A, B>::type>
        static typename std::enable_if<
                  std::is_same<Key, common>::value
               && !details::has_insert<Container<C, N>>::value
            , Container<C, N>>::type get(A start, B end) {
            Container<C, N> container = {{ 0 }};
 
            for (std::size_t i = 0; i < N; ++i)
                container[i] = get<common>(start, end);
 
            return container;
        }
 
        template<typename T, std::size_t N>
        static T* get( T( &array )[ N ] ) {
            return std::addressof( array[ get<std::size_t>( 0, N - 1 ) ] );
        }
 
        template<typename Dist, typename... Args>
        static typename Dist::result_type get( Args&&... args ) {
            return Dist{ std::forward<Args>( args )... }( engine_instance( ) );
        }
 
        template<typename Dist>
        static typename Dist::result_type get( Dist& dist ) {
            return dist( engine_instance( ) );
        }
 
        template<typename RandomIt>
        static void shuffle( RandomIt first, RandomIt last ) {
            std::shuffle( first, last, engine_instance( ) );
        }
 
        template<typename Container>
        static void shuffle( Container& container ) {
            shuffle( std::begin( container ), std::end( container ) );
        }
 
        static Engine get_engine( ) {
            return engine_instance( );
        }
 
        static Engine& engine() {
            return engine_instance();
        }
    protected:
        static Engine& engine_instance( ) {
            thread_local Engine engine{ Seeder{ }( ) };
            return engine;
        }
    };
 
    template<
        typename Engine,
        typename Seeder = seeder_default,
        template<typename> class IntegerDist = std::uniform_int_distribution,
        template<typename> class RealDist = std::uniform_real_distribution,
        typename BoolDist = std::bernoulli_distribution
    >
    class basic_random_local {
    public:
        using engine_type = Engine;
 
        using seeder_type = Seeder;
 
        template<typename T>
        using integer_dist_t = IntegerDist<T>;
 
        template<typename T>
        using real_dist_t = RealDist<T>;
 
        using bool_dist_t = BoolDist;
 
        using common = details::common;
 
        static constexpr typename Engine::result_type min( ) {
            return Engine::min( );
        }
 
        static constexpr typename Engine::result_type max( ) {
            return Engine::max( );
        }
 
        void discard( const unsigned long long z ) {
            m_engine.discard( z );
        }
 
        void reseed( ) {
            Seeder seeder;
            seed( seeder( ) );
        }
 
        void seed( const typename Engine::result_type value =
                          Engine::default_seed ) {
            m_engine.seed( value );
        }
 
        template<typename Sseq>
        void seed( Sseq& seq ) {
            m_engine.seed( seq );
        }
 
        typename Engine::result_type get( ) {
            return m_engine( );
        }
 
        bool is_equal( const Engine& other ) {
            return m_engine == other;
        }
 
        template<typename CharT, typename Traits>
        void serialize( std::basic_ostream<CharT, Traits>& ost ) {
            ost << m_engine;
        }
 
        template<typename CharT, typename Traits>
        void deserialize( std::basic_istream<CharT, Traits>& ist ) {
            ist >> m_engine;
        }
 
        template<typename T>
        typename std::enable_if<details::is_uniform_int<T>::value
            , T>::type get( T from = std::numeric_limits<T>::min( ),
                            T to = std::numeric_limits<T>::max( ) ) {
            if( from < to ) // Allow range from higher to lower
                return IntegerDist<T>{ from, to }( m_engine );
            return IntegerDist<T>{ to, from }( m_engine );
        }
 
        template<typename T>
        typename std::enable_if<details::is_uniform_real<T>::value
            , T>::type get( T from = std::numeric_limits<T>::min( ),
                            T to = std::numeric_limits<T>::max( ) ) {
            if( from < to ) // Allow range from higher to lower
                return RealDist<T>{ from, to }( m_engine );
            return RealDist<T>{ to, from }( m_engine );
        }
 
        template<typename T>
        typename std::enable_if<details::is_byte<T>::value
            , T>::type get( T from = std::numeric_limits<T>::min( ),
                            T to = std::numeric_limits<T>::max( ) ) {
            // Choose between short and unsigned short for byte conversion
            using short_t = typename std::conditional<std::is_signed<T>::value,
                short, unsigned short>::type;
 
            return static_cast<T>( get<short_t>( from, to ) );
        }
 
        template<
            typename Key,
            typename A,
            typename B, 
            typename C = typename std::common_type<A, B>::type
        >
        typename std::enable_if<
               std::is_same<Key, common>::value
            && details::is_supported_number<A>::value
            && details::is_supported_number<B>::value
            // Prevent implicit type conversion from singed to unsigned types
            && std::is_signed<A>::value != std::is_unsigned<B>::value
            , C>::type get( A from = std::numeric_limits<A>::min( ),
                            B to = std::numeric_limits<B>::max( ) ) {
            return get( static_cast<C>( from ), static_cast<C>( to ) );
        }
 
        template<typename T>
        typename std::enable_if<details::is_supported_character<T>::value
            , T>::type get(T from = std::numeric_limits<T>::min(),
                T to = std::numeric_limits<T>::max()) {
            if (from < to) // Allow range from higher to lower
                return static_cast<T>(IntegerDist<std::int64_t>{ static_cast<std::int64_t>(from), static_cast<std::int64_t>(to) }(m_engine));
            return static_cast<T>(IntegerDist<std::int64_t>{ static_cast<std::int64_t>(to), static_cast<std::int64_t>(from) }(m_engine));
        }
 
        template<typename T>
        typename std::enable_if<std::is_same<T, bool>::value
            , bool>::type get( const double probability = 0.5 ) {
            assert( 0 <= probability && 1 >= probability ); // out of [0; 1] range
            return BoolDist{ probability }( m_engine );
        }
 
        template<typename T>
        T get( std::initializer_list<T> init_list ) {
            assert( 0u != init_list.size( ) );
            return *get( init_list.begin( ), init_list.end( ) );
        }
 
        template<typename InputIt>
        typename std::enable_if<details::is_iterator<InputIt>::value
            , InputIt>::type get( InputIt first, InputIt last ) {
            const auto size = std::distance( first, last );
            if( 0 == size ) return last;
            using diff_t = typename std::iterator_traits<InputIt>::difference_type;
            return std::next( first, get<diff_t>( 0, size - 1 ) );
        }
 
        template<typename Container>
        auto get( Container& container ) -> 
            typename std::enable_if<details::is_iterator<
                decltype(std::begin(container))>::value
                , decltype(std::begin(container))
            >::type {
            return get( std::begin( container ), std::end( container ) );
        }
 
        template<template<typename...> class Container, typename A>
        typename std::enable_if<
                details::has_reserve<Container<A>>::value
            , Container<A>>::type get(A from, A to, std::size_t size) {
            Container<A> container;
 
            container.reserve(size);
            for (std::size_t i = 0; i < size; ++i)
                container.insert(std::end(container), get(from, to));
 
            return container;
        }
 
        template<
            template<typename...> class Container,
            typename Key,
            typename A,
            typename B,
            typename C = typename std::common_type<A, B>::type>
        typename std::enable_if<
                   std::is_same<Key, common>::value
                && details::has_reserve<Container<A>>::value
            , Container<C>>::type get(A start, B end, std::size_t size) {
            Container<C> container;
 
            container.reserve(size);
            for (std::size_t i = 0; i < size; ++i)
                container.insert(std::end(container), get<common>(start, end));
 
            return container;
        }
 
        template<template<typename...> class Container, typename A>
        typename std::enable_if<
              !details::has_reserve<Container<A>>::value
            , Container<A>>::type get(A start, A end, std::size_t size) {
            Container<A> container;
 
            for (std::size_t i = 0; i < size; ++i)
                container.insert(std::end(container), get(start, end));
 
            return container;
        }
 
        template<
            template<typename...> class Container,
            typename Key,
            typename A,
            typename B,
            typename C = typename std::common_type<A, B>::type>
        typename std::enable_if<
                 std::is_same<Key, common>::value
              && !details::has_reserve<Container<C>>::value
            , Container<C>>::type get(A start, B end, std::size_t size) {
            Container<C> container;
 
            for (std::size_t i = 0; i < size; ++i)
                container.insert(std::end(container), get<common>(start, end));
 
            return container;
        }
 
        template<template<typename AA, std::size_t NN, typename...> class Container, std::size_t N, typename A>
        typename std::enable_if<
               !details::has_insert<Container<A, N>>::value
            , Container<A, N>>::type get(A start, A end) {
            Container<A, N> container = {{ 0 }};
 
            for (std::size_t i = 0; i < N; ++i)
                container[i] = get(start, end);
 
            return container;
        }
 
        template<
            template<typename AA, std::size_t NN, typename...> class Container,
            std::size_t N,
            typename Key,
            typename A,
            typename B,
            typename C = typename std::common_type<A, B>::type>
        typename std::enable_if<
                  std::is_same<Key, common>::value
               && !details::has_insert<Container<C, N>>::value
            , Container<C, N>>::type get(A start, B end) {
            Container<C, N> container = {{ 0 }};
 
            for (std::size_t i = 0; i < N; ++i)
                container[i] = get<common>(start, end);
 
            return container;
        }
 
        template<typename T, std::size_t N>
        T* get( T( &array )[ N ] ) {
            return std::addressof( array[ get<std::size_t>( 0, N - 1 ) ] );
        }
 
        template<typename Dist, typename... Args>
        typename Dist::result_type get( Args&&... args ) {
            return Dist{ std::forward<Args>( args )... }( m_engine );
        }
 
        template<typename Dist>
        typename Dist::result_type get( Dist& dist ) {
            return dist( m_engine );
        }
 
        template<typename RandomIt>
        void shuffle( RandomIt first, RandomIt last ) {
            std::shuffle( first, last, m_engine );
        }
 
        template<typename Container>
        void shuffle( Container& container ) {
            shuffle( std::begin( container ), std::end( container ) );
        }
 
        Engine get_engine( ) const {
            return m_engine;
        }
 
        Engine& engine() {
            return m_engine;
        }
    protected:
        static Engine make_seeded_engine( ) {
            // Make seeder instance for seed return by reference like std::seed_seq
            return Engine{ Seeder{ }( ) };
        }
    protected:
        Engine m_engine{ make_seeded_engine( ) };
    };
 
    using random_static = basic_random_static<std::mt19937>;
 
    using random_thread_local = basic_random_thread_local<std::mt19937>;
 
    using random_local = basic_random_local<std::mt19937>;
 
} // namespace effolkronium
 
#endif // #ifndef EFFOLKRONIUM_RANDOM_HPP