Vary range of uniform_int_distribution

Question

So i have a Random object:

typedef unsigned int uint32;

class Random {
public:
    Random() = default;
    Random(std::mt19937::result_type seed) : eng(seed) {}

private:
    uint32 DrawNumber();
    std::mt19937 eng{std::random_device{}()};
    std::uniform_int_distribution<uint32> uniform_dist{0, UINT32_MAX};
};

uint32 Random::DrawNumber()
{
    return uniform_dist(eng);
}

What's the best way I can vary (through another function or otherwise) the upper bound of of the distribution?

(also willing to take advice on other style issues)

Caril

You can't vary the bounds of the distribution after first initializing them. How you should proceed depends a lot on what you use your random numbers for and why you need to change the bounds. – Fivepenny

@Fivepenny That is wrong; you can. – Entasis

Possible duplicate of Use std::uniform_int_distribution and define its range later (pre-empting objections: yes, that's newer and has a somewhat tangential title, but IMO it has a more on-topic accepted answer and generally gets to the point faster) – Entasis

At the risk of being biased, the 2 different questions have essentially the same accepted answer - "Another way would be to add a method..." part of the other question's answer is the same as the accepted answer here. This answer also includes usage, with a std::mt19937. That said the .param method is new. Since this question is now 5 years old, perhaps the best course of action would be to mark the other as a duplicate and amend the accepted answer here? Alternatively just leave the questions as is :) – Caril

Answer 1

Distribution objects are lightweight. Simply construct a new distribution when you need a random number. I use this approach in a game engine, and, after benchmarking, it's comparable to using good old rand().

Also, I've asked how to vary the range of distribution on GoingNative 2013 live stream, and Stephen T. Lavavej, a member of the standard committee, suggested to simply create new distributions, as it shouldn't be a performance issue.

Here's how I would write your code:

using uint32 = unsigned int;

class Random {
public:
    Random() = default;
    Random(std::mt19937::result_type seed) : eng(seed) {}
    uint32 DrawNumber(uint32 min, uint32 max);

private:        
    std::mt19937 eng{std::random_device{}()};
};

uint32 Random::DrawNumber(uint32 min, uint32 max)
{
    return std::uniform_int_distribution<uint32>{min, max}(eng);
}

Arbitrator

I think i just watched that Going Native stream :) Although, i'm (a bit) new to C++ (especially C++11) and a fair amount of it went over my head :L If you're sure that there's no significant overhead in creating a new distribution each time, i'll probably go with this – Caril

I've benchmarked it. Overhead is minimal and can be ignored. (This is being said by a micro-optimization nazi). Also, there is no other way of changing a distribution's bounds. – Arbitrator

Ok, great, thanks very much :) I'll probably go with a constant 0 as the min, and UINT32_MAX as a default for max. – Caril

This creates a new distribution, rather than modifying an existing one. As such, it doesn't answer the question, regardless of how quickly the class in instantiated. – Bade

Found this answer via google and I have concerns. You are creating a new std::mt19937 engine object every time you construct a Random; the exact opposite of what S.T.L. suggests... – Hasheem

Answer 2

You can simply create a std::uniform_int_distribution<uint32>::param_type and modify the range using the param() method. You can cut down the template noise with decltype :

decltype(uniform_dist.param()) new_range (0, upper);
uniform_dist.param(new_range);

Bade

Answer 3

I'm making the DrawNumber function public for my example. You can provide an overload that takes an upper bound, and then pass a new uniform_int_distribution::param_type to uniform_int_distribution::operator()

The param_type can be constructed using the same arguments as the corresponding distribution.

From N3337, §26.5.1.6/9 [rand.req.dist]

For each of the constructors of D taking arguments corresponding to parameters of the distribution, P shall have a corresponding constructor subject to the same requirements and taking arguments identical in number, type, and default values. Moreover, for each of the member functions of D that return values corresponding to parameters of the distribution, P shall have a corresponding member function with the identical name, type, and semantics.

where D is the type of a random number distribution function object and P is the type named by D's associated param_type

#include <iostream>
#include <random>

typedef unsigned int uint32;

class Random {
public:
    Random() = default;
    Random(std::mt19937::result_type seed) : eng(seed) {}

    uint32 DrawNumber();
    uint32 DrawNumber(uint32 ub);

private:
    std::mt19937 eng{std::random_device{}()};
    std::uniform_int_distribution<uint32> uniform_dist{0, UINT32_MAX};
};

uint32 Random::DrawNumber()
{
    return uniform_dist(eng);
}

uint32 Random::DrawNumber(uint32 ub)
{
    return uniform_dist(eng, decltype(uniform_dist)::param_type(0, ub));
}

int main()
{
  Random r;
  std::cout << r.DrawNumber() << std::endl;
  std::cout << r.DrawNumber(42) << std::endl;
}

Gardal