# Golang rand, crypto: Random Number Generators

Use the rand package and generate random numbers. Call rand.Int and Seed.**Rand.** Everything, even the color of the grass, may be deterministic in this world. But many events seem random. We use "math/rand" in Go to simulate this effect.

**With rand.Int** we get random integers. And with rand.Seed we initialize the pseudo-random number generator that the Go language uses.

**An intro program.** This program generates 5 pseudo-random numbers. It uses a default seed value (which initializes the generator) of 1.

**So:** The program generates the same numbers each time. Try running it multiple times—it always has the same result.

**Int:** This method returns a positive (non-negative) int. No fractional or negative values are possible.

**Tip:** To change the initial series of values returned by rand.Int, use the Seed method.

**Golang program that uses rand.Int**
package main
import (
"fmt"
"math/rand"
)
func main() {*
// Loop five times.
*for i := 0; i < 5; i++ {*
// Get random positive integer.
*value := __rand.Int__()
fmt.Println(value)
}
}
**Output**
5577006791947779410
8674665223082153551
6129484611666145821
4037200794235010051
3916589616287113937

**Seed.** This method initializes the random source. When we use a seed based on the current time, each program execution will start with a different random sequence.

**Here:** We use the current Nanoseconds from the time. We cast this to an int64 to seed the number generator.

Time**Note:** If you run this program many times, each execution will print a different random number.

**Golang program that uses Seed**
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {*
// Call Seed, using current nanoseconds.
*rand.__Seed__(int64(time.Now().Nanosecond()))*
// Random int will be different each program execution.
*value := rand.Int()
fmt.Println(value)
}
**Output**
6912970929678809162

**Rand.Perm.** This function is useful. It generates slices of Ints with values from 0 to the max index of the slice. Each value appears only once. So it creates permutations of Ints.

**Here:** We call rand.Perm with an argument of 5. So the numbers 0, 1, 2, 3, and 4 are randomly arranged in slices of 5 elements.

**Important:** Perm uses the default random source. So we would need to use Seed to avoid the same output on each program run.

**Golang program that uses rand.Perm**
package main
import (
"fmt"
"math/rand"
)
func main() {
for i := 0; i < 5; i++ {*
// Use rand.Perm to generate a random array of numbers.
*numbers := rand.__Perm__(*5*)
fmt.Println(numbers)
}
}
**Output**
[0 4 2 3 1]
[4 1 2 0 3]
[2 3 0 4 1]
[0 4 2 1 3]
[1 0 4 2 3]

**Crypto rand.** Random numbers come in varying levels of randomness. For the best random numbers built into Go, we should use crypto rand. We must use the "math/big" package.

**Program:** We call the rand.Int method in "crypto/rand" 20 times. We get values that are from 0 to 99 inclusive (we never get 100).

**Golang program that uses crypto rand**
package main
import (
"crypto/rand"
"math/big"
"fmt"
)
func main() {*
// Generate 20 random numbers with exclusive max of 100.
// ... So max value returned is 99.
// All values returned are 0 or greater as well.
*for i := 0; i < 20; i++ {
result, _ := __rand.Int__(rand.Reader, big.NewInt(100))
fmt.Println(result)
}
}
**Output**
54
77
56
21
56
81
55
16
57
88
95
58
12
74
23
35
72
29
25
68

**Global versus local.** With top-level rand methods, we use a global source. But we can create Rand instances that are local. This helps with many randomness requirements.

© 2007-2020 Sam Allen. Every person is special and unique. Send bug reports to info@dotnetperls.com.