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;

static constexpr bool value =

std::is_same<T, float>::value

|| std::is_same<T, double>::value

|| std::is_same<T, long double>::value;

static constexpr bool value =

std::is_same<T, signed char>::value

|| std::is_same<T, unsigned char>::value;

static constexpr bool value =

is_byte <T>::value

|| is_uniform_real<T>::value

|| is_uniform_int <T>::value;

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;

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;

/// return seed sequence

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( ) ),

} };

public:

basic_random_static( ) = delete;

/// Type of used random number engine

using engine_type = Engine;

/// Type of used random number seeder

using seeder_type = Seeder;

/// Type of used integer distribution

template<typename T>

using integer_dist_t = IntegerDist<T>;

/// Type of used real distribution

template<typename T>

using real_dist_t = RealDist<T>;

/// Type of used bool distribution

using bool_dist_t = BoolDist;

/// Key type for getting common type numbers or objects

using common = details::common;

/**

static constexpr typename Engine::result_type min( ) {

return Engine::min( );

}

/**

static constexpr typename Engine::result_type max( ) {

return Engine::max( );

}

/// Advances the internal state by z times

static void discard( const unsigned long long z ) {

engine_instance( ).discard( z );

}

/// Reseed by Seeder

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 );

}

/// return random number from engine in [min(), max()] range

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<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 ) );

}

/// return internal engine by copy

static Engine get_engine( ) {

return engine_instance( );

}

/// return internal engine by ref

static Engine& engine() {

return engine_instance();

}

protected:

/// get reference to the static engine instance

static Engine& engine_instance( ) {

static Engine engine{ Seeder{ }( ) };

return engine;

}

public:

basic_random_thread_local( ) = delete;

/// Type of used random number engine

using engine_type = Engine;

/// Type of used random number seeder

using seeder_type = Seeder;

/// Type of used integer distribution

template<typename T>

using integer_dist_t = IntegerDist<T>;

/// Type of used real distribution

template<typename T>

using real_dist_t = RealDist<T>;

/// Type of used bool distribution

using bool_dist_t = BoolDist;

/// Key type for getting common type numbers or objects

using common = details::common;

/**

static constexpr typename Engine::result_type min( ) {

return Engine::min( );

}

/**

static constexpr typename Engine::result_type max( ) {

return Engine::max( );

}

/// Advances the internal state by z times

static void discard( const unsigned long long z ) {

engine_instance( ).discard( z );

}

/// Reseed by Seeder

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 );

}

/// return random number from engine in [min(), max()] range

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<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 ) );

}

/// return internal engine by copy

static Engine get_engine( ) {

return engine_instance( );

}

/// return internal engine by ref

static Engine& engine() {

return engine_instance();

}

protected:

/// get reference to the thread local engine instance

static Engine& engine_instance( ) {

thread_local Engine engine{ Seeder{ }( ) };

return engine;

}

public:

/// Type of used random number engine

using engine_type = Engine;

/// Type of used random number seeder

using seeder_type = Seeder;

/// Type of used integer distribution

template<typename T>

using integer_dist_t = IntegerDist<T>;

/// Type of used real distribution

template<typename T>

using real_dist_t = RealDist<T>;

/// Type of used bool distribution

using bool_dist_t = BoolDist;

/// Key type for getting common type numbers or objects

using common = details::common;

/**

static constexpr typename Engine::result_type min( ) {

return Engine::min( );

}

/**

static constexpr typename Engine::result_type max( ) {

return Engine::max( );

}

/// Advances the internal state by z times

void discard( const unsigned long long z ) {

m_engine.discard( z );

}

/// Reseed by Seeder

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 );

}

/// return random number from engine in [min(), max()] range

typename Engine::result_type get( ) {

return m_engine( );

}

/**

bool is_equal( const Engine& other ) {

return m_engine == other;

}

/**