我可以使用单个“ default_random_engine”来创建多个正态分布的数字集吗？

Question

I want to generate a set of unit vectors (for any arbitrary dimension), which are evenly distributed across all directions. For this I generate normally distributed numbers for each vector component and scale the result by the inverse of the magnitude.

My question : Can I use a single std::default_random_engine to generate numbers for all components of my vector or does every component require its own engine?

Afaik, each component needs to be Gaussian-distributed independently for the math to work out and I cannot assess the difference between the two scenarios. Here's a MWE with a single RNG (allocation and normalization of vectors is omitted here).

std::vector<std::vector<double>> GenerateUnitVecs(size_t dimension, size_t count)
{
    std::vector<std::vector<double>> result;

    /* Set up a _single_ RNG */
    size_t seed = GetSeed(); // system_clock
    std::default_random_engine gen(seed);
    std::normal_distribution<double> distribution(0.0, 1.0); 

    /* Generate _multiple_ (independent?) distributions */
    for(size_t ii = 0; ii < count; ++ii){
        std::vector<double> vec;
        for(size_t comp = 0; comp < dimension; ++comp)
            vec.push_back(distribution(gen)); // <-- random number goes here

        result.push_back(vec);
    }
    return result;
}

Thank you.

Answer 1

I am assuming you are not generating random numbers in parallel. Then theoretically, there is no problem with generating random independent Gaussian vectors with one engine.

Each call to std::normal_distribution 's () operator gives you a random real-valued number following specified Gaussian distribution. Successive calls of () operator give you independent samples. The implementation in gcc (my version: 4.8 ) uses the Marsaglia Polar method for standard normal random number generation. You can read this Wikipedia page for more detail.

However, for rigorous scientific research that demands high quality randomness and a huge amount of random samples, I would recommend using the Mersenne-Twister engine ( mt19937 32-bit or 64-bit) instead of the default engine, since it is based on a well-established method, has long period and performs well on statistical random tests.

Answer 2

The OP asked:

My question: Can I use a single std::default_random_engine to generate numbers for all components of my vector or does every component require its own engine?

---

I would suggest as others have stated in the comments about not using std::default_random_engine and instead use std::random_device or std::chrono::high_resolution_clock

---

To use random_device for a normal distribution or Gaussian it is quite simple:

#include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <random>
#include <cmath>

int main() {

    std::random_device rd{};
    std::mt19937 gen{ rd() };

    // values near the mean are the most likely
    // standard deviation affects the dispersion of generated values from the mean
    std::normal_distribution<> d{5,2};

    std::map<int, int> hist{};
    for ( int n=0; n<10000; ++n ) {
        ++hist[std::round(d(gen))];
    }
    for ( auto p : hist ) {
        std::cout << std::setw(2)
                  << p.first << ' ' << std::string(p.second/200, '*' ) << '\n';
    }
}

---

To use std::chrono::high_resolution_clock : there is a little more work but just as easy.

#include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <random>
#include <cmath>
#include <limits>
#include <chrono>

class ChronoClock {
public:
    using Clock = std::conditional_t<std::chrono::high_resolution_clock::is_steady,
        std::chrono::high_resolution_clock,
        std::chrono::steady_clock>;

    static unsigned int getTimeNow() {
        unsigned int now = static_cast<unsigned int>(Clock::now().time_since_epoch().count());
        return now;
    }
};

int main() {       

    /*static*/ std::mt19937 gen{}; // Can be either static or not.

    gen.seed( ChronoClock::getTimeNow() );

    // values near the mean are the most likely
    // standard deviation affects the dispersion of generated values from the mean
    std::normal_distribution<> d{5,2};

    std::map<int, int> hist{};
    for ( int n=0; n<10000; ++n ) {
        ++hist[std::round(d(gen))];
    }
    for ( auto p : hist ) {
        std::cout << std::setw(2)
                  << p.first << ' ' << std::string(p.second/200, '*' ) << '\n';
    }
}

As you can see from the examples above where these are shown here from cppreference.com there is a single engine, single seed, and a single distribution, that it is generating random numbers or sets of random numbers with a single engine.

---

EDIT - Additionally you can use a class that I've written as a wrapper class for random engines and random distributions . You can refer to this answer of mine here .