Show Lecture.RandomNumbers as a slide show.

CS253 Random Numbers

Inclusion

To use C++ random numbers, you need to:

    
#include <random>

To use old C random numbers (don’t ), you need to:

    
#include <cstdlib>

Philosophy

“Computers can’t do anything truly random. Only a person can do that.”

• Stop trying to prove your superiority.
  • If you believe that you have something special that distinguishes you from machines, you’re talking religion, not CS.
• My dog is pretty random.
• You’re somewhat predictable.
  • An online rock-paper-scissors program beats people 60% of the time over more than a million games, because people are lousy at being random.

Old Stuff

Patron Saint of Randomness

• There are several C random number generators, of varying degrees of standardization:
  • rand(), srand()
  • random(), srandom()
  • drand48(), erand48(), lrand48(), nrand48(), mrand48(), jrand48(), srand48()
• They still work ok, but avoid them for new C++ code.
• They mix up generation and distribution something terrible.
• Also, each family has a separate seeding function.
• Also also, there’s no way to save/restore state!

Traditional Method

Traditional random number generators work like this:

unsigned long n = 1;
for (int i=0; i<5; i++) {
    n = n * 16807 % 2147483647;
    cout << n << '\n';
}

16807
282475249
1622650073
984943658
1144108930

• It’s fast, simple, and good enough for many tasks. However …
  • What happens if n is zero?
  • What number always follows 16807?
  • How many possible states does this RNG (Random Number Generator) have?

Overview

• In C++, random numbers have:
  • Generators:
    Generate uniformly-distributed random integers, typically zero or one to a big number.
  • Distributions:
    Take uniformly-distributed random integers, and transform them into other distributions with different ranges.
• Examples:
  • Picking a card (uniform, but discrete)
  • Rolling 3d6 (bell-shaped, but discrete)
  • Human height (bell-shaped, continuous)

Generators

Default Engine

Define a random-number generator, and use () to generate a number. This is not a function call, because gen is an object, not a function. It’s operator().

#include <random>
#include <iostream>
using namespace std;

int main() {
    default_random_engine gen;
    for (int i=0; i<5; i++)
        cout << gen() << '\n';
}

16807
282475249
1622650073
984943658
1144108930

I won’t bother with the #includes in subsequent examples.

Mersenne Twister

• Here’s a different, 64-bit generator.
• Use .min() and .max() to find out the range of a given generator.

mt19937_64 gen;
cout << "range is " << gen.min() << "…" << gen.max() << "\n\n";
for (int i=0; i<3; i++)
    cout << gen() << '\n';

range is 0…18446744073709551615

14514284786278117030
4620546740167642908
13109570281517897720

Ranges

Generators have varying ranges:

ranlux24 rl;
minstd_rand mr;
random_device rd;
mt19937_64 mt;

cout << "ranlux24:      " << rl.min() << "…" << rl.max() << '\n'
     << "minstd_rand:   " << mr.min() << "…" << mr.max() << '\n'
     << "random_device: " << rd.min() << "…" << rd.max() << '\n'
     << "mt19937_64:    " << mt.min() << "…" << mt.max() << '\n';

ranlux24:      0…16777215
minstd_rand:   1…2147483646
random_device: 0…4294967295
mt19937_64:    0…18446744073709551615

Hey, look! Zero is not a possible return value for minstd_rand.

Save/Restore

A generator can save & restore state to an I/O stream:

ranlux24 gen;
cout << gen() << ' ';
cout << gen() << endl;
ofstream("state") << gen;
system("wc -c state");
cout << gen() << ' ';
cout << gen() << '\n';
ifstream("state") >> gen;
cout << gen() << ' ';
cout << gen() << '\n';

15039276 16323925
209 state
14283486 7150092
14283486 7150092

True randomness

random_device a, b, c;
cout << a() << '\n'
     << b() << '\n'
     << c() << '\n';

9119532
1799738189
418658452

• random_device is, ideally, truly random, and not pseudo-random.
• Intel computers have an RDRAND instruction.
• It might depend on random things like human typing intervals, network packets arrival times, or radioactive decay.
• If true randomness isn’t available, it resorts to pseudo-random numbers.
• It could pause waiting for randomness to become available.
• Use it sparingly.

Cloudflare

The hosting service Cloudflare uses a unique source of randomness.

Seeding

minstd_rand a, b, c(123);
cout << a() << ' ' << a() << '\n';
cout << b() << ' ' << b() << '\n';
cout << c() << ' ' << c() << '\n';

48271 182605794
48271 182605794
5937333 985676192

• Great—we can “seed” the random number generator with a value.
• This way, we can reproduce our pseudo-random sequences.
• Consider random testing: we want to be able to reproduce the sequence if we find an error.
• How to choose the random seed?
  • It should probably be … random.

Seed with process ID

auto seed = getpid();
minstd_rand a(seed);
for (int i=0; i<5; i++)
    cout << a() << '\n';

122956460
1733963999
2001053904
1206041571
698487218

• You can seed with your process id.
• OK for casual use, but the seed is easily guessed.
• Process IDs are usually 15- or 16-bit quantities, so there are generally only 32768 or 65536 of them. Somebody could easily try them all.

Seed with time

// seconds since start of 1970
auto seed = time(nullptr);
minstd_rand a(seed);
for (int i=0; i<5; i++)
    cout << a() << '\n';

839448308
140340225
1199578337
96847619
2007000877

• You can seed with a time-related value.
• Two runs may occur within the same second, and so produce identical random sequences.
• OK for casual use, but the seed is easily guessed.
• There are only 86,400 seconds in a day. Somebody could easily try them all.

Seed with more accurate time

Nanoseconds make more possibilities:

auto seed = chrono::high_resolution_clock::now()
            .time_since_epoch().count();
cout << "Seed: " << seed << '\n';
minstd_rand a(seed);
for (int i=0; i<5; i++)
    cout << a() << '\n';

Seed: 1732204900288785675
471443988
188537489
2004919180
955702078
451302284

• There are 86,400,000,000,000 nanoseconds in a day.

Better Seeding

• Many generators have more than 32 or 64 bits of state.
• Therefore, you can seed them with more than 32 or 64 bits.
• If you’re doing something very important, and somebody guessing your seed, and hence predicting your sequence, would be catastrophic:
  • on-line poker 🂺 🂻 🂽 🂾 🂱
  • encryption of military communications ⚔️ 🔫 💣 🥆 ☢️
  • encrypted email re: extra-marital affairs 💔
• That’s beyond the scope of this discussion.

Seed with random_device

random_device rd;
auto seed = rd();
minstd_rand0 a(seed);
for (int i=0; i<5; i++)
    cout << a() << '\n';

1719777796
1323012399
823708955
1396818123
30964257

You can seed with random_device, if you know that it’s truly random.

Not good enough.

• Great, so we know how to generate a number 1…2,147,483,646
  or perhaps 0…18,446,744,073,709,551,615
• How often do we want to do that?
• Sometimes, we want integers with different ranges.
• Or, perhaps we want floating-point numbers.
• Maybe spread out linearly, or a bell-shaped curve, Poisson, etc.
• This is a job for a distribution.

Caution

Resist the urge to hack your own distribution—it’s hard. Just use the standard distributions.

minstd_rand r;
int first_half = 0;
for (int i=0; i<100'000'000; i++)
    if (r() % 1'000'000'000 < 500'000'000)
        first_half++;
cout << first_half << '\n';

53435616

Distributions

uniform_int_distribution

auto seed = random_device()();  //❓❓❓
mt19937 gen(seed);
uniform_int_distribution<int> dist(1,6);
for (int y=0; y<10; y++) {
    for (int x=0; x<40; x++)
        cout << dist(gen) << ' ';
    cout << '\n';
}

3 5 2 2 2 5 3 3 2 6 2 2 2 1 1 1 4 2 6 2 3 4 4 3 6 1 3 6 4 2 6 3 6 2 1 4 4 5 5 2 
6 2 1 6 1 3 6 1 2 3 2 6 5 1 6 6 1 5 4 1 6 2 6 3 5 4 1 5 3 1 2 5 6 4 5 3 1 6 1 5 
3 6 1 1 1 4 6 2 3 6 4 4 6 2 5 4 4 2 5 2 3 3 1 5 2 5 5 5 2 6 4 5 2 1 3 5 2 1 5 3 
1 4 2 3 1 4 1 6 4 3 4 1 2 6 6 3 1 6 6 5 3 1 2 4 4 1 5 1 1 3 3 1 6 4 1 5 2 4 5 5 
4 1 3 4 5 3 5 6 3 5 6 2 2 6 2 5 3 4 4 5 4 4 5 4 3 2 3 6 3 5 4 6 2 4 6 3 5 2 6 6 
2 4 2 5 1 6 5 6 3 3 4 1 6 6 3 5 5 4 1 1 6 1 1 6 4 6 6 5 4 4 3 2 2 2 2 5 5 1 1 1 
6 1 3 2 1 6 6 4 2 5 3 6 2 3 5 6 2 5 5 2 3 2 5 1 2 3 6 6 6 4 2 1 4 3 2 3 2 5 3 1 
3 4 3 2 5 1 2 4 4 5 4 1 4 3 4 2 5 1 5 3 2 1 3 4 2 5 3 5 4 5 1 5 4 6 2 2 1 6 5 5 
5 1 1 1 3 6 6 3 4 4 4 3 4 1 5 1 2 2 1 6 6 1 2 5 1 5 1 2 6 5 5 6 1 6 3 4 2 2 2 5 
5 2 3 4 5 2 4 4 3 6 3 3 4 1 6 4 2 6 4 3 1 1 5 2 2 2 3 5 4 1 3 2 5 5 6 3 1 5 1 5 

uniform_real_distribution

auto seed = random_device()();
ranlux48 gen(seed);
uniform_real_distribution<> dist(18.0, 25.0);
for (int y=0; y<5; y++) {
    for (int x=0; x<10; x++)
        cout << fixed << setprecision(3) << dist(gen) << ' ';
    cout << '\n';
}

24.665 22.864 23.226 20.100 23.739 21.643 19.600 18.041 23.892 20.713 
21.677 22.659 19.975 21.875 19.614 20.721 20.177 22.414 22.721 23.138 
22.919 24.891 21.717 19.666 24.387 21.907 23.813 20.285 19.627 22.430 
21.304 22.587 20.188 21.686 22.157 23.831 23.432 20.706 21.117 24.619 
22.691 22.997 22.900 18.771 18.456 18.216 21.181 24.673 21.660 23.945 

Boolean Values

Yield true 42% of time:

random_device rd;
knuth_b gen(rd());
bernoulli_distribution dist(0.42);
constexpr int nrolls = 1'000'000;

int count=0;
for (int i=0; i<nrolls; i++)
    if (dist(gen))
        count++;

cout << "true: " << count*100.0/nrolls << "%\n";

true: 41.9693%

Histogram

random_device rd;
mt19937_64 gen(rd());
normal_distribution<> dist(21.5, 1.5);
map<int,int> tally;
for (int i=0; i<10000; i++)
    tally[dist(gen)]++;
for (auto p : tally)
    cout << p.first << ": " << string(p.second/100,'#') << '\n';

15: 
16: 
17: 
18: ###
19: ##########
20: #####################
21: ##########################
22: ####################
23: ##########
24: ###
25: 
26: 
27: 

Passwords

random_device rd;
auto seed = rd();
ranlux24 gen(seed);
uniform_int_distribution<char> dist('A','~');
for (int y=0; y<8; y++) {
    string pw;
    for (int x=0; x<32; x++)
        pw += dist(gen);
    cout << "Password: " << pw << '\n';
}

Password: [fpWFgly_QWbVgp}Je\OVGy|hr`FwSBQ
Password: ]Av\njnI]VJCfKBLMUj`YFJ_SQZObsMg
Password: nBuQeGVke_OYK_^STzlCyS|z{ziTw{Tx
Password: SBozGDJGpaxf[WS{~RJI~wl[CoHTGpeV
Password: |D]ohBkX[tI}E`EXoMk}s_kPltOUHGAm
Password: ^AjnE\rIeu{}n{p\XdMJXAVqXz_WX]CF
Password: U_Nc_SErmhWmItLTp~OwUMaM}YOAxvEw
Password: aa~QjHWJETOXyDIsCYO\ievs|P^_rMBJ

Even though we’re using uniform_int_distribution, which has int right there in its name, it’s uniform_int_distribution<char>, so we get characters. Think of them as 8-bit integers that display differently.