Bitcoin ABC 0.26.3
P2P Digital Currency

An extremely fast random generator. More...
#include <nanobench.h>
Public Types  
using  result_type = uint64_t 
This RNG provides 64bit randomness.  
Public Member Functions  
Rng (Rng const &)=delete  
As a safety precausion, we don't allow copying.  
Rng &  operator= (Rng const &)=delete 
Same as Rng(Rng const&), we don't allow assignment.  
Rng (Rng &&) noexcept=default  
Rng &  operator= (Rng &&) noexcept=default 
~Rng () noexcept=default  
Rng ()  
Creates a new Random generator with random seed.  
Rng (uint64_t seed) noexcept  
Rng (uint64_t x, uint64_t y) noexcept  
Rng (std::vector< uint64_t > const &data)  
ANKERL_NANOBENCH (NODISCARD) Rng copy() const noexcept  
Creates a copy of the Rng, thus the copy provides exactly the same random sequence as the original.  
uint64_t  operator() () noexcept 
Produces a 64bit random value.  
uint32_t  bounded (uint32_t range) noexcept 
Generates a random number between 0 and range (excluding range).  
double  uniform01 () noexcept 
Provides a random uniform double value between 0 and 1.  
template<typename Container >  
void  shuffle (Container &container) noexcept 
Shuffles all entries in the given container.  
std::vector< uint64_t >  state () const 
Extracts the full state of the generator, e.g.  
Static Public Member Functions  
static constexpr uint64_t()  min () 
static constexpr uint64_t()  max () 
Static Private Member Functions  
static constexpr uint64_t  rotl (uint64_t x, unsigned k) noexcept 
Private Attributes  
uint64_t  mX 
uint64_t  mY 
An extremely fast random generator.
Currently, this implements RomuDuoJr, developed by Mark Overton. Source: http://www.romurandom.org/
RomuDuoJr is extremely fast and provides reasonable good randomness. Not enough for large jobs, but definitely good enough for a benchmarking framework.
This random generator is a dropin replacement for the generators supplied by <random>
. It is not cryptographically secure. It's intended purpose is to be very fast so that benchmarks that make use of randomness are not distorted too much by the random generator.
Rng also provides a few nonstandard helpers, optimized for speed.
Definition at line 477 of file nanobench.h.
This RNG provides 64bit randomness.
Definition at line 482 of file nanobench.h.

delete 
As a safety precausion, we don't allow copying.
Copying a PRNG would mean you would have two random generators that produce the same sequence, which is generally not what one wants. Instead create a new rng with the default constructor Rng(), which is automatically seeded from std::random_device
. If you really need a copy, use copy().

defaultnoexcept 

defaultnoexcept 
ankerl::nanobench::Rng::Rng  (  ) 
Creates a new Random generator with random seed.
Instead of a default seed (as the random generators from the STD), this properly seeds the random generator from std::random_device
. It guarantees correct seeding. Note that seeding can be relatively slow, depending on the source of randomness used. So it is best to create a Rng once and use it for all your randomness purposes.

explicitnoexcept 
Creates a new Rng that is seeded with a specific seed. Each Rng created from the same seed will produce the same randomness sequence. This can be useful for deterministic behavior.
embed:rst .. note:: The random algorithm might change between nanobench releases. Whenever a faster and/or better random generator becomes available, I will switch the implementation.
As per the Romu paper, this seeds the Rng with splitMix64 algorithm and performs 10 initial rounds for further mixing up of the internal state.
seed  The 64bit seed. All values are allowed, even 0. 
ankerl::nanobench::Rng::Rng  (  std::vector< uint64_t > const &  data  ) 

noexcept 
Creates a copy of the Rng, thus the copy provides exactly the same random sequence as the original.
Generates a random number between 0 and range (excluding range).
The algorithm only produces 32bit numbers, and is slightly biased. The effect is quite small unless your range is close to the maximum value of an integer. It is possible to correct the bias with rejection sampling (see here, but this is most likely irrelevant in practices for the purposes of this Rng.
See Daniel Lemire's blog post A fast alternative to the modulo reduction
range  Upper exclusive range. E.g a value of 3 will generate random numbers 0, 1, 2. 
Definition at line 1129 of file nanobench.h.

inlinenoexcept 
Produces a 64bit random value.
This should be very fast, thus it is marked as inline. In my benchmark, this is ~46 times faster than std::default_random_engine
for producing 64bit random values. It seems that the fastest std contender is std::mt19937_64
. Still, this RNG is 23 times as fast.
Definition at line 1119 of file nanobench.h.
Same as Rng(Rng const&), we don't allow assignment.
If you need a new Rng create one with the default constructor Rng().

staticconstexprprivatenoexcept 
Definition at line 1155 of file nanobench.h.
Shuffles all entries in the given container.
Although this has a slight bias due to the implementation of bounded(), this is preferable to std::shuffle
because it is over 5 times faster. See Daniel Lemire's blog post Fast random shuffling.
container  The whole container will be shuffled. 
Definition at line 1145 of file nanobench.h.
std::vector< uint64_t > ankerl::nanobench::Rng::state  (  )  const 
Extracts the full state of the generator, e.g.
for serialization. For this RNG this is just 2 values, but to stay API compatible with future implementations that potentially use more state, we use a vector.

inlinenoexcept 
Provides a random uniform double value between 0 and 1.
This uses the method described in Generating uniform doubles in the unit interval, and is extremely fast.
Definition at line 1135 of file nanobench.h.

private 
Definition at line 597 of file nanobench.h.

private 
Definition at line 598 of file nanobench.h.