C++ 快速正态随机数生成器

Question

I'm using the mt19937 generator to generate normal random numbers as shown below:

normal_distribution<double> normalDistr(0, 1);    
mt19937 generator(123);
vector<double> randNums(1000000);
for (size_t i = 0; i != 1000000; ++i)
{
    randNums[i] = normalDistr(generator);
}

The above code works, however since I'm generating more than 100 million normal random numbers in my code, the above is very slow.

Is there a faster way to generate normal random numbers?

The following is some background on how the code would be used:

• Quality of the random numbers is not that important
• Precision of the numbers is not that important, either double or float is OK
• The normal distribution always has mean = 0 and sigma = 1

---

EDIT :

@Dúthomhas, Andrew:

After profiling the following function is taking up more than 50% of the time:

std::normal_distribution<double>::_Eval<std::mersenne_twister_engine<unsigned int,32,624,397,31,2567483615,11,4294967295,7,2636928640,15,4022730752,18,1812433‌​253> >

Answer 1

Most importantly, do you really need 100,000,000 random numbers simultaneously ? The writing to and subsequent reading from RAM of all these data unavoidably requires significant time. If you only need the random numbers one at a time, you should avoid that.

Assuming that you do need all of these numbers in RAM, then you should first profile your code if you really want to know where the CPU time is spent/lost.

Second, you should avoid unnecessary re-allocation and initialisation of the data. This is most easily done by using std::vector::reserve(final_size) in conjunction with std::vector::push_back() .

Third, you could use a faster RNG than std::mt19937 . That RNG is recommended when the quality of the numbers is of importance. The online documentation says that the lagged Fibonacci generator (implemented in std:: subtract_with_carry_engine ) is fast, but it may not have a long enough recurrence period -- you must check this. Alternatively, you may want to use std::min_stdrand (which uses the linear congruential generator )

std::vector<double> make_normal_random(std::size_t number,
                                       std::uint_fast32_t seed)
{
  std::normal_distribution<double> normalDistr(0,1);    
  std::min_stdrand generator(seed);
  std::vector<double> randNums;
  randNums.reserve(number);
  while(number--)
    randNums.push_back(normalDistr(generator));
  return randNums;
}

Answer 2

You also will want to look into std::vector reserve rather than resize. It will allow you get all the memory you will need in 1 shot. I am assuming you don't need all 100 million doubles at once?

Answer 3

If it really is the generator that is the cause of the performance degradation then use the ordinary rand function (you need to draw numbers in pairs), transform to a float or double in 0, 1 then apply the Box Muller transformation.

That will be hard to beat in terms of time, but note that the statistical properties are no better than rand .

A numerical recipes routine gasdev does this - you should be able to download a copy.