Create a gist now

Instantly share code, notes, and snippets.

What would you like to do?
Addresses common issues with C++11 random number generation; makes good seeding easier, and makes using RNGs easy while retaining all the power.
/*
* Random-Number Utilities (randutil)
* Addresses common issues with C++11 random number generation.
* Makes good seeding easier, and makes using RNGs easy while retaining
* all the power.
*
* The MIT License (MIT)
*
* Copyright (c) 2015 Melissa E. O'Neill
*
* 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 RANDUTILS_HPP
#define RANDUTILS_HPP 1
/*
* This header includes three class templates that can help make C++11
* random number generation easier to use.
*
* randutils::seed_seq_fe
*
* Fixed-Entropy Seed sequence
*
* Provides a replacement for std::seed_seq that avoids problems with bias,
* performs better in empirical statistical tests, and executes faster in
* normal-sized use cases.
*
* In normal use, it's accessed via one of the following type aliases
*
* randutils::seed_seq_fe128
* randutils::seed_seq_fe256
*
* It's discussed in detail at
* http://www.pcg-random.org/posts/developing-a-seed_seq-alternative.html
* and the motivation for its creation (what's wrong with std::seed_seq) here
* http://www.pcg-random.org/posts/cpp-seeding-surprises.html
*
*
* randutils::auto_seeded
*
* Extends a seed sequence class with a nondeterministic default constructor.
* Uses a variety of local sources of entropy to portably initialize any
* seed sequence to a good default state.
*
* In normal use, it's accessed via one of the following type aliases, which
* use seed_seq_fe128 and seed_seq_fe256 above.
*
* randutils::auto_seed_128
* randutils::auto_seed_256
*
* It's discussed in detail at
* http://www.pcg-random.org/posts/simple-portable-cpp-seed-entropy.html
* and its motivation (why you can't just use std::random_device) here
* http://www.pcg-random.org/posts/cpps-random_device.html
*
*
* randutils::random_generator
*
* An Easy-to-Use Random API
*
* Provides all the power of C++11's random number facility in an easy-to
* use wrapper.
*
* In normal use, it's accessed via one of the following type aliases, which
* also use auto_seed_256 by default
*
* randutils::default_rng
* randutils::mt19937_rng
*
* It's discussed in detail at
* http://www.pcg-random.org/posts/ease-of-use-without-loss-of-power.html
*/
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <random>
#include <array>
#include <functional> // for std::hash
#include <initializer_list>
#include <utility>
#include <type_traits>
#include <iterator>
#include <chrono>
#include <thread>
#include <algorithm>
// Ugly platform-specific code for auto_seeded
#if !defined(RANDUTILS_CPU_ENTROPY) && defined(__has_builtin)
#if __has_builtin(__builtin_readcyclecounter)
#define RANDUTILS_CPU_ENTROPY __builtin_readcyclecounter()
#endif
#endif
#if !defined(RANDUTILS_CPU_ENTROPY)
#if __i386__
#if __GNUC__
#define RANDUTILS_CPU_ENTROPY __builtin_ia32_rdtsc()
#else
#include <immintrin.h>
#define RANDUTILS_CPU_ENTROPY __rdtsc()
#endif
#else
#define RANDUTILS_CPU_ENTROPY 0
#endif
#endif
#if defined(RANDUTILS_GETPID)
// Already defined externally
#elif defined(_WIN64) || defined(_WIN32)
#include <process.h>
#define RANDUTILS_GETPID _getpid()
#elif defined(__unix__) || defined(__unix) \
|| (defined(__APPLE__) && defined(__MACH__))
#include <unistd.h>
#define RANDUTILS_GETPID getpid()
#else
#define RANDUTILS_GETPID 0
#endif
#if __cpp_constexpr >= 201304L
#define RANDUTILS_GENERALIZED_CONSTEXPR constexpr
#else
#define RANDUTILS_GENERALIZED_CONSTEXPR
#endif
namespace randutils {
//////////////////////////////////////////////////////////////////////////////
//
// seed_seq_fe
//
//////////////////////////////////////////////////////////////////////////////
/*
* seed_seq_fe implements a fixed-entropy seed sequence; it conforms to all
* the requirements of a Seed Sequence concept.
*
* seed_seq_fe<N> implements a seed sequence which seeds based on a store of
* N * 32 bits of entropy. Typically, it would be initialized with N or more
* integers.
*
* seed_seq_fe128 and seed_seq_fe256 are provided as convenience typedefs for
* 128- and 256-bit entropy stores respectively. These variants outperform
* std::seed_seq, while being better mixing the bits it is provided as entropy.
* In almost all common use cases, they serve as better drop-in replacements
* for seed_seq.
*
* Technical details
*
* Assuming it constructed with M seed integers as input, it exhibits the
* following properties
*
* * Diffusion/Avalanche: A single-bit change in any of the M inputs has a
* 50% chance of flipping every bit in the bitstream produced by generate.
* Initializing the N-word entropy store with M words requires O(N * M)
* time precisely because of the avalanche requirements. Once constructed,
* calls to generate are linear in the number of words generated.
*
* * Bias freedom/Bijection: If M == N, the state of the entropy store is a
* bijection from the M inputs (i.e., no states occur twice, none are
* omitted). If M > N the number of times each state can occur is the same
* (each state occurs 2**(32*(M-N)) times, where ** is the power function).
* If M < N, some states cannot occur (bias) but no state occurs more
* than once (it's impossible to avoid bias if M < N; ideally N should not
* be chosen so that it is more than M).
*
* Likewise, the generate function has similar properties (with the entropy
* store as the input data). If more outputs are requested than there is
* entropy, some outputs cannot occur. For example, the Mersenne Twister
* will request 624 outputs, to initialize it's 19937-bit state, which is
* much larger than a 128-bit or 256-bit entropy pool. But in practice,
* limiting the Mersenne Twister to 2**128 possible initializations gives
* us enough initializations to give a unique initialization to trillions
* of computers for billions of years. If you really have 624 words of
* *real* high-quality entropy you want to use, you probably don't need
* an entropy mixer like this class at all. But if you *really* want to,
* nothing is stopping you from creating a randutils::seed_seq_fe<624>.
*
* * As a consequence of the above properties, if all parts of the provided
* seed data are kept constant except one, and the remaining part is varied
* through K different states, K different output sequences will be produced.
*
* * Also, because the amount of entropy stored is fixed, this class never
* performs dynamic allocation and is free of the possibility of generating
* an exception.
*
* Ideas used to implement this code include hashing, a simple PCG generator
* based on an MCG base with an XorShift output function and permutation
* functions on tuples.
*
* More detail at
* http://www.pcg-random.org/posts/developing-a-seed_seq-alternative.html
*/
template <size_t count = 4, typename IntRep = uint32_t,
size_t mix_rounds = 1 + (count <= 2)>
struct seed_seq_fe {
public:
// types
typedef IntRep result_type;
private:
static constexpr uint32_t INIT_A = 0x43b0d7e5;
static constexpr uint32_t MULT_A = 0x931e8875;
static constexpr uint32_t INIT_B = 0x8b51f9dd;
static constexpr uint32_t MULT_B = 0x58f38ded;
static constexpr uint32_t MIX_MULT_L = 0xca01f9dd;
static constexpr uint32_t MIX_MULT_R = 0x4973f715;
static constexpr uint32_t XSHIFT = sizeof(IntRep)*8/2;
RANDUTILS_GENERALIZED_CONSTEXPR
static IntRep fast_exp(IntRep x, IntRep power)
{
IntRep result = IntRep(1);
IntRep multiplier = x;
while (power != IntRep(0)) {
IntRep thismult = power & IntRep(1) ? multiplier : IntRep(1);
result *= thismult;
power >>= 1;
multiplier *= multiplier;
}
return result;
}
std::array<IntRep, count> mixer_;
template <typename InputIter>
void mix_entropy(InputIter begin, InputIter end);
public:
seed_seq_fe(const seed_seq_fe&) = delete;
void operator=(const seed_seq_fe&) = delete;
template <typename T>
seed_seq_fe(std::initializer_list<T> init)
{
seed(init.begin(), init.end());
}
template <typename InputIter>
seed_seq_fe(InputIter begin, InputIter end)
{
seed(begin, end);
}
// generating functions
template <typename RandomAccessIterator>
void generate(RandomAccessIterator first, RandomAccessIterator last) const;
static constexpr size_t size()
{
return count;
}
template <typename OutputIterator>
void param(OutputIterator dest) const;
template <typename InputIter>
void seed(InputIter begin, InputIter end)
{
mix_entropy(begin, end);
// For very small sizes, we do some additional mixing. For normal
// sizes, this loop never performs any iterations.
for (size_t i = 1; i < mix_rounds; ++i)
stir();
}
seed_seq_fe& stir()
{
mix_entropy(mixer_.begin(), mixer_.end());
return *this;
}
};
template <size_t count, typename IntRep, size_t r>
template <typename InputIter>
void seed_seq_fe<count, IntRep, r>::mix_entropy(InputIter begin, InputIter end)
{
auto hash_const = INIT_A;
auto hash = [&](IntRep value) {
value ^= hash_const;
hash_const *= MULT_A;
value *= hash_const;
value ^= value >> XSHIFT;
return value;
};
auto mix = [](IntRep x, IntRep y) {
IntRep result = MIX_MULT_L*x - MIX_MULT_R*y;
result ^= result >> XSHIFT;
return result;
};
InputIter current = begin;
for (auto& elem : mixer_) {
if (current != end)
elem = hash(*current++);
else
elem = hash(0U);
}
for (auto& src : mixer_)
for (auto& dest : mixer_)
if (&src != &dest)
dest = mix(dest,hash(src));
for (; current != end; ++current)
for (auto& dest : mixer_)
dest = mix(dest,hash(*current));
}
template <size_t count, typename IntRep, size_t mix_rounds>
template <typename OutputIterator>
void seed_seq_fe<count,IntRep,mix_rounds>::param(OutputIterator dest) const
{
const IntRep INV_A = fast_exp(MULT_A, IntRep(-1));
const IntRep MIX_INV_L = fast_exp(MIX_MULT_L, IntRep(-1));
auto mixer_copy = mixer_;
for (size_t round = 0; round < mix_rounds; ++round) {
// Advance to the final value. We'll backtrack from that.
auto hash_const = INIT_A*fast_exp(MULT_A, IntRep(count * count));
for (auto src = mixer_copy.rbegin(); src != mixer_copy.rend(); ++src)
for (auto dest = mixer_copy.rbegin(); dest != mixer_copy.rend();
++dest)
if (src != dest) {
IntRep revhashed = *src;
auto mult_const = hash_const;
hash_const *= INV_A;
revhashed ^= hash_const;
revhashed *= mult_const;
revhashed ^= revhashed >> XSHIFT;
IntRep unmixed = *dest;
unmixed ^= unmixed >> XSHIFT;
unmixed += MIX_MULT_R*revhashed;
unmixed *= MIX_INV_L;
*dest = unmixed;
}
for (auto i = mixer_copy.rbegin(); i != mixer_copy.rend(); ++i) {
IntRep unhashed = *i;
unhashed ^= unhashed >> XSHIFT;
unhashed *= fast_exp(hash_const, IntRep(-1));
hash_const *= INV_A;
unhashed ^= hash_const;
*i = unhashed;
}
}
std::copy(mixer_copy.begin(), mixer_copy.end(), dest);
}
template <size_t count, typename IntRep, size_t mix_rounds>
template <typename RandomAccessIterator>
void seed_seq_fe<count,IntRep,mix_rounds>::generate(
RandomAccessIterator dest_begin,
RandomAccessIterator dest_end) const
{
auto src_begin = mixer_.begin();
auto src_end = mixer_.end();
auto src = src_begin;
auto hash_const = INIT_B;
for (auto dest = dest_begin; dest != dest_end; ++dest) {
auto dataval = *src;
if (++src == src_end)
src = src_begin;
dataval ^= hash_const;
hash_const *= MULT_B;
dataval *= hash_const;
dataval ^= dataval >> XSHIFT;
*dest = dataval;
}
}
using seed_seq_fe128 = seed_seq_fe<4, uint32_t>;
using seed_seq_fe256 = seed_seq_fe<8, uint32_t>;
//////////////////////////////////////////////////////////////////////////////
//
// auto_seeded
//
//////////////////////////////////////////////////////////////////////////////
/*
* randutils::auto_seeded
*
* Extends a seed sequence class with a nondeterministic default constructor.
* Uses a variety of local sources of entropy to portably initialize any
* seed sequence to a good default state.
*
* In normal use, it's accessed via one of the following type aliases, which
* use seed_seq_fe128 and seed_seq_fe256 above.
*
* randutils::auto_seed_128
* randutils::auto_seed_256
*
* It's discussed in detail at
* http://www.pcg-random.org/posts/simple-portable-cpp-seed-entropy.html
* and its motivation (why you can't just use std::random_device) here
* http://www.pcg-random.org/posts/cpps-random_device.html
*/
template <typename SeedSeq>
class auto_seeded : public SeedSeq {
using default_seeds = std::array<uint32_t, 11>;
template <typename T>
static uint32_t crushto32(T value)
{
if (sizeof(T) <= 4)
return uint32_t(value);
else {
uint64_t result = uint64_t(value);
result *= 0xbc2ad017d719504d;
return uint32_t(result ^ (result >> 32));
}
}
template <typename T>
static uint32_t hash(T&& value)
{
return crushto32(std::hash<typename std::remove_reference<
typename std::remove_cv<T>::type>::type>{}(
std::forward<T>(value)));
}
static constexpr uint32_t fnv(uint32_t hash, const char* pos)
{
return *pos == '\0' ? hash : fnv((hash * 16777619U) ^ *pos, pos+1);
}
default_seeds local_entropy()
{
// This is a constant that changes every time we compile the code
constexpr uint32_t compile_stamp =
fnv(2166136261U, __DATE__ __TIME__ __FILE__);
// Some people think you shouldn't use the random device much because
// on some platforms it could be expensive to call or "use up" vital
// system-wide entropy, so we just call it once.
static uint32_t random_int = std::random_device{}();
// The heap can vary from run to run as well.
void* malloc_addr = malloc(sizeof(int));
free(malloc_addr);
auto heap = hash(malloc_addr);
auto stack = hash(&malloc_addr);
// Every call, we increment our random int. We don't care about race
// conditons. The more, the merrier.
random_int += 0xedf19156;
// Classic seed, the time. It ought to change, especially since
// this is (hopefully) nanosecond resolution time.
auto hitime = std::chrono::high_resolution_clock::now()
.time_since_epoch().count();
// Address of the thing being initialized. That can mean that
// different seed sequences in different places in memory will be
// different. Even for the same object, it may vary from run to
// run in systems with ASLR, such as OS X, but on Linux it might not
// unless we compile with -fPIC -pic.
auto self_data = hash(this);
// The address of the time function. It should hopefully be in
// a system library that hopefully isn't always in the same place
// (might not change until system is rebooted though)
auto time_func = hash(&std::chrono::high_resolution_clock::now);
// The address of the exit function. It should hopefully be in
// a system library that hopefully isn't always in the same place
// (might not change until system is rebooted though). Hopefully
// it's in a different library from time_func.
auto exit_func = hash(&_Exit);
// The address of a local function. That may be in a totally
// different part of memory. On OS X it'll vary from run to run thanks
// to ASLR, on Linux it might not unless we compile with -fPIC -pic.
// Need the cast because it's an overloaded
// function and we need to pick the right one.
auto self_func = hash(
static_cast<uint32_t (*)(uint64_t)>(
&auto_seeded::crushto32));
// Hash our thread id. It seems to vary from run to run on OS X, not
// so much on Linux.
auto thread_id = hash(std::this_thread::get_id());
// Hash of the ID of a type. May or may not vary, depending on
// implementation.
#if __cpp_rtti || __GXX_RTTI
auto type_id = crushto32(typeid(*this).hash_code());
#else
uint32_t type_id = 0;
#endif
// Platform-specific entropy
auto pid = crushto32(RANDUTILS_GETPID);
auto cpu = crushto32(RANDUTILS_CPU_ENTROPY);
return {{random_int, crushto32(hitime), stack, heap, self_data,
self_func, exit_func, thread_id, type_id, pid, cpu}};
}
public:
using SeedSeq::SeedSeq;
using base_seed_seq = SeedSeq;
const base_seed_seq& base() const
{
return *this;
}
base_seed_seq& base()
{
return *this;
}
auto_seeded(default_seeds seeds)
: SeedSeq(seeds.begin(), seeds.end())
{
// Nothing else to do
}
auto_seeded()
: auto_seeded(local_entropy())
{
// Nothing else to do
}
};
using auto_seed_128 = auto_seeded<seed_seq_fe128>;
using auto_seed_256 = auto_seeded<seed_seq_fe256>;
//////////////////////////////////////////////////////////////////////////////
//
// uniform_distribution
//
//////////////////////////////////////////////////////////////////////////////
/*
* This template typedef provides either
* - uniform_int_distribution, or
* - uniform_real_distribution
* depending on the provided type
*/
template <typename Numeric>
using uniform_distribution = typename std::conditional<
std::is_integral<Numeric>::value,
std::uniform_int_distribution<Numeric>,
std::uniform_real_distribution<Numeric> >::type;
//////////////////////////////////////////////////////////////////////////////
//
// random_generator
//
//////////////////////////////////////////////////////////////////////////////
/*
* randutils::random_generator
*
* An Easy-to-Use Random API
*
* Provides all the power of C++11's random number facility in an easy-to
* use wrapper.
*
* In normal use, it's accessed via one of the following type aliases, which
* also use auto_seed_256 by default
*
* randutils::default_rng
* randutils::mt19937_rng
*
* It's discussed in detail at
* http://www.pcg-random.org/posts/ease-of-use-without-loss-of-power.html
*/
template <typename RandomEngine = std::default_random_engine,
typename DefaultSeedSeq = auto_seed_256>
class random_generator {
public:
using engine_type = RandomEngine;
using default_seed_type = DefaultSeedSeq;
private:
engine_type engine_;
// This SFNAE evilness provides a mechanism to cast classes that aren't
// themselves (technically) Seed Sequences but derive from a seed
// sequence to be passed to functions that require actual Seed Squences.
// To do so, the class should provide a the type base_seed_seq and a
// base() member function.
template <typename T>
static constexpr bool has_base_seed_seq(typename T::base_seed_seq*)
{
return true;
}
template <typename T>
static constexpr bool has_base_seed_seq(...)
{
return false;
}
template <typename SeedSeqBased>
static auto seed_seq_cast(SeedSeqBased&& seq,
typename std::enable_if<
has_base_seed_seq<SeedSeqBased>(0)>::type* = 0)
-> decltype(seq.base())
{
return seq.base();
}
template <typename SeedSeq>
static SeedSeq seed_seq_cast(SeedSeq&& seq,
typename std::enable_if<
!has_base_seed_seq<SeedSeq>(0)>::type* = 0)
{
return seq;
}
public:
template <typename Seeding = default_seed_type,
typename... Params>
random_generator(Seeding&& seeding = default_seed_type{})
: engine_{seed_seq_cast(std::forward<Seeding>(seeding))}
{
// Nothing (else) to do
}
// Work around Clang DR777 bug in Clang 3.6 and earlier by adding a
// redundant overload rather than mixing parameter packs and default
// arguments.
// https://llvm.org/bugs/show_bug.cgi?id=23029
template <typename Seeding,
typename... Params>
random_generator(Seeding&& seeding, Params&&... params)
: engine_{seed_seq_cast(std::forward<Seeding>(seeding)),
std::forward<Params>(params)...}
{
// Nothing (else) to do
}
template <typename Seeding = default_seed_type,
typename... Params>
void seed(Seeding&& seeding = default_seed_type{})
{
engine_.seed(seed_seq_cast(seeding));
}
// Work around Clang DR777 bug in Clang 3.6 and earlier by adding a
// redundant overload rather than mixing parameter packs and default
// arguments.
// https://llvm.org/bugs/show_bug.cgi?id=23029
template <typename Seeding,
typename... Params>
void seed(Seeding&& seeding, Params&&... params)
{
engine_.seed(seed_seq_cast(seeding), std::forward<Params>(params)...);
}
RandomEngine& engine()
{
return engine_;
}
template <typename ResultType,
template <typename> class DistTmpl = std::normal_distribution,
typename... Params>
ResultType variate(Params&&... params)
{
DistTmpl<ResultType> dist(std::forward<Params>(params)...);
return dist(engine_);
}
template <typename Numeric>
Numeric uniform(Numeric lower, Numeric upper)
{
return variate<Numeric,uniform_distribution>(lower, upper);
}
template <template <typename> class DistTmpl = uniform_distribution,
typename Iter,
typename... Params>
void generate(Iter first, Iter last, Params&&... params)
{
using result_type =
typename std::remove_reference<decltype(*(first))>::type;
DistTmpl<result_type> dist(std::forward<Params>(params)...);
std::generate(first, last, [&]{ return dist(engine_); });
}
template <template <typename> class DistTmpl = uniform_distribution,
typename Range,
typename... Params>
void generate(Range&& range, Params&&... params)
{
generate<DistTmpl>(std::begin(range), std::end(range),
std::forward<Params>(params)...);
}
template <typename Iter>
void shuffle(Iter first, Iter last)
{
std::shuffle(first, last, engine_);
}
template <typename Range>
void shuffle(Range&& range)
{
shuffle(std::begin(range), std::end(range));
}
template <typename Iter>
Iter choose(Iter first, Iter last)
{
auto dist = std::distance(first, last);
if (dist < 2)
return first;
using distance_type = decltype(dist);
distance_type choice = uniform(distance_type(0), --dist);
std::advance(first, choice);
return first;
}
template <typename Range>
auto choose(Range&& range) -> decltype(std::begin(range))
{
return choose(std::begin(range), std::end(range));
}
template <typename Range>
auto pick(Range&& range) -> decltype(*std::begin(range))
{
return *choose(std::begin(range), std::end(range));
}
template <typename T>
auto pick(std::initializer_list<T> range) -> decltype(*range.begin())
{
return *choose(range.begin(), range.end());
}
template <typename Size, typename Iter>
Iter sample(Size to_go, Iter first, Iter last)
{
auto total = std::distance(first, last);
using value_type = decltype(*first);
return std::stable_partition(first, last,
[&](const value_type&) {
--total;
using distance_type = decltype(total);
distance_type zero{};
if (uniform(zero, total) < to_go) {
--to_go;
return true;
} else {
return false;
}
});
}
template <typename Size, typename Range>
auto sample(Size to_go, Range&& range) -> decltype(std::begin(range))
{
return sample(to_go, std::begin(range), std::end(range));
}
};
using default_rng = random_generator<std::default_random_engine>;
using mt19937_rng = random_generator<std::mt19937>;
}
#endif // RANDUTILS_HPP
@PetterS

This comment has been minimized.

Show comment Hide comment
@PetterS

PetterS Dec 15, 2015

choose() traverses the collection too much if the iterators are not random access.

PetterS commented Dec 15, 2015

choose() traverses the collection too much if the iterators are not random access.

@dodheim

This comment has been minimized.

Show comment Hide comment
@dodheim

dodheim Aug 16, 2016

The update to auto_seeded::hash() is backwards – std::hash<typename std::remove_reference<typename std::remove_cv<T>::type>::type> should be std::hash<typename std::remove_cv<typename std::remove_reference<T>::type>::type> (or possibly just std::hash<typename std::decay<T>::type>).

dodheim commented Aug 16, 2016

The update to auto_seeded::hash() is backwards – std::hash<typename std::remove_reference<typename std::remove_cv<T>::type>::type> should be std::hash<typename std::remove_cv<typename std::remove_reference<T>::type>::type> (or possibly just std::hash<typename std::decay<T>::type>).

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment