# Generating random numbers

Published on Mon Feb 6, 2017

Let’s go crazy and generate some random numbers!

But are they truly random? And why are we generating them?!

## Why?

Why do we want to make random numbers?

First we needs to understand that computers *can not* make truly random numbers. Instead they can generate pseudo-random numbers using an algorithm - which is often based on a starting value called the *seed*.

In computer science there are (at least) three big areas where random numbers are useful:

- Statistics
- Games/gaming
- Cryptography

## How?

In many programming languages it is very trivial to generate a pseudo-random number.

Usually the number will be a floating point value between 0 and 1 - and to get a value in the interval we need to use this as a factor for the interval we want numbers in (pseudo-code):

```
min_value + (random() * (max_value - min_value))
```

We’ll start by making a small example program (in Go) that simulate a roll with a D6 (six-sided die):

```
package main
import "fmt"
import "math/rand"
const sides = 6
func main() {
fmt.Println(rand.Intn(sides) + 1)
}
```

Check out the example on the Go playground - or on your own computer - it generates the same number every time!

It is because of the seed! Every time it is run it uses the same seed value. To generate another number - or even another sequence of numbers - we need to feed the algorithm a unique seed value. If it is fed the *same* value it will produce the *same* sequence of random numbers.

The following example have the changes needed to generate a *unique* sequence using the current timestamp in nano seconds as the *seed* (you can run this on the Go playground as well, but it will produce the same sequence every time, as the time used there is fixed):

```
package main
import "fmt"
import "math/rand"
import "time"
const sides = 6
func main() {
rand.Seed(time.Now().UnixNano())
for i := 0; i < 100; i++ {
fmt.Println(rand.Intn(sides) + 1)
}
}
```

## Is it random?

I’ve run a program that made random numbers between 1 and 6 - over two billion times! The result are output every 1.000.000 iterations by counting the occurences for each possible number.

The following graph shows the distribution progression:

As the graph shows the start is a bit rough but the distribution progress towards perfect ^{1}⁄_{6}.

This does not really show how random the numbers are.

In the previous examples we’ve seen that using the same seed again will produce the exact same sequence of *random* numbers - this in itself should be *proof* they are in fact not really random.

But it’s good enough for most applications - such as computer games.

The examples shown/described here is in the companion repository on GitHub along with the sample output data - over two billion iterations each, run 10 times.