Random Numbers

• This is chapter 23 of Gregorie
• Again, this is a surface level coverage of the topic.
• But first
• What is wrong with rand, srand,...
  • It is 70's technology.
  • It uses the linear congruential generator algorithm
    • $X_{i+1} = (aX_i +c) mod m$
    • In gcc
      • a = 110351525
      • c = 12345
      • m = $2^{31}$
    • It is fast and requires little memory.
    • The bottom bits (extracted with %) tend to be less random
    • Values will not repeat until the entire loop of numbers is produced
    • Poorly chosen values for a,c and m are problematic.
    • And for the m given above, only about a thousand random numbers are acceptable.
• Warning, don't try to randomize things be adding more randomness. This will probably not increase the randomness and will likely decrease it.
  • Randomness is apparently hard.
  • People have studied it for a long time.
  • And these experts have developed the methods we will use.
• In C++11 a new method was introduced.
  • All are part of the random library.
• Random engines
  • There are a number of different engines that can be used to generate random numbers
  • linear_congruential_engine is the standard random number generator.
  • random_device is cool
    • If supported, it uses hardware, network interaction, keypresses or other physical or types of events to generate random numbers.
    • This device has a .entropy() member function
      • If it is greater than 0, then it is available.
    • This should not be your primary RNG.
    • You can deplete the entropy pool quickly
    • But it is a good source of seed.

    • random_device seedDevice
      int  seed
      if (seedDevice.entropy() > 0) {
          seed = seedDevice();
      } else {
          seed = time(null);
      }
                  

  • The mersenne_twister_engine appears to be the current state of the art for pseudo random number generators.
    • It is fast
    • It requires some storage
    • But it has a huge period.
• These engines require some very specialized parameters so the library provides some engine adapters
  • For the sake of time, we will look at three
    • mt19937
    • mt19937-64
    • minstd_rand
  • all have the () operator defined to produce a random integer
  • All have .min() and .max()
  • all have .seed()
  • Take a look at RandomEngines.cpp
• So far this is nice, a little more complex, but much better way to generate random sequences.
• But the great addition, in my opinion, is the ability to shape the random output to a distribution.
• This is done with a random distribution
  • You know, a normal curve
  • Or something else.
• You will probably want uniform_int_distribution or uniform_real_distribution
  • Each take a min and a max in the constructor.

  • uniform_int_distribution<int> uniformIntDistribution{1,20};
    uniform_real_distribution<double> uniformRealDistribution{1.0, 21.0};
            

  • Each then takes an engine and will produce a uniform distribution in that range.

  • cout << uniformIntDistribution(engine) << endl;
            

  • There are many others. I have examples of a few in random.cpp
• The bind command binds a parameter to a function and returns a new function.
  • This is useful here

  • uniform_int_distribution<int> uniformIntDistribution{1,20};
    auto uniformIntGenerator{bind(uniformIntDistribution, engine)}; 

  • This binds the engine to the distribution.
  • So uniformIntGenerator is callable as a function

  • cout << uniformIntGenerator() << endl;
             

• I made a class that I probably want to revise after making these nodes.
• Look at RNGT.h
• Look at RNGT.cpp
• Look at random.cpp for
  • The map class
  • command line arguments.