c++ Gaussian random number generator keeps generating same sequence

Question

I'm trying to implement a C++ class that generates Gaussian (aka normal) random floats using an API similar to Python's Numpy random number generator:

numpy.random.normal(loc, scale)

where loc is the mean and scale is the standard deviation.

Below is my attempt.

#include <cstdio>
#include <random>
#include <ctime>


class Gaussian
{
    std::default_random_engine gen;

    public:
        Gaussian()
        {
            srand((unsigned int)time(NULL));
        }

        double get(double mean, double std)
        {
            std::normal_distribution<double> nd(mean, std);
            return nd(gen);
        }
};

The problem is that in my main() function, I generate 10 random doubles, and the sequence is always the same. I am using g++ on a Mac.

int main(int argc, char**argv)
{
    srand((unsigned int)time(NULL));

    Gaussian g;
    int N = 10;
    double mean = 50.0;
    double std = 2.0;

    for (int i = 0; i < N; i++) {
        double value = g.get(mean, std);
        printf("%f\n", value);
    }
}

// Compile: g++ main.cpp

Consistently produces over multiple invocations:

47.520528
53.224019
52.765603
48.191707
46.679143
50.151444
50.194442
49.542437
51.169795
51.069510

What is going on?

Answer 1

The std::default_random_engine gen needs to be seeded differently if you want different output. The default constructor, which is what it is constructed with in your example, will always seed with default_seed, which will always be the same.

You can supply a seed using any standard C++ method to construct a class member, such as an initializer list in your constructor:

public:
    Gaussian() : gen{ time(NULL) } 
{ }

Or you could call gen.seed() in the constructor, which would be less efficient since the generator is effectively being seeded twice, once at construction and again when seed() is called.

The exact engine used by std::default_random_engine is implementation defined, but we do know that srand() has no effect on it.^* This is really the fundamental flaw of the example code: The attempt to seed the random generator with srand() has no effect.

It also worth noting the time(NULL) returns the time in seconds. If you initialize the generator multiple times in the same second, you'll get the same output. std::chrono::high_resolution_clock::now().time_since_epoch().count() might be a better choice for simple clock based seeding.

Also note that re-creating the distribution object for each individual random number is inefficient. It would be better to keep using the same object if many random numbers of the same mean and std. dev. are needed.

^* This comes from C++11 §[rand.req.eng] Table 117: The default constructor "[c]reates an engine with the same initial state as all other default-constructed engines of type E." And the function call operator "[a]dvances e’s state e_i to e_i+1 = TA(e_i) ..." This leaves no possibility for srand() to change the state of a default constructed engine nor to affect an engine's state once constructed (i.e., re-seed it).

Answer 2

Thanks to the answer from TrentP, I came up with the class below.

I also found these resources useful:

https://en.cppreference.com/w/cpp/numeric/random/normal_distribution

Can I change a distribution parameters?

Should I use std::default_random_engine or should I use std::mt19937?

#include <random>

// Class for generating Gaussian random numbers.
class Gaussian
{
    std::random_device _rd{}; // For random seeding.
    std::mt19937 _gen{_rd()};
    std::normal_distribution<double> _normal_dist;

    public:
        Gaussian(double mean, double stdev)
        {
            set(mean, stdev);
        }

        // Update the Gaussian distribution parameters.
        void set(double mean, double stdev)
        {
            std::normal_distribution<double>::param_type new_params(mean, stdev);
            _normal_dist.param(new_params);
        }

        double get()
        {
            return _normal_dist(_gen);
        }
};