How Ruby generates random numbers

Ruby's method of generating random numbers: first call srand anywhere at the beginning of the program; then when you run it, you can generate a series of different seemingly random numbers.

The operating environment of this article: Windows 7 system, Dell G3 computer, ruby ​​version 3.0.0.

Generating random numbers in Ruby

It can be used in range programs (usually games and simulations) to generate random numbers. While no computer can generate truly random numbers, Ruby does provide access to methods that return pseudo-random numbers.

Numbers are not actually random

No computer can generate truly random numbers purely through calculation. The best they can do is generate pseudo-random numbers, which are a set of numbers that look random but aren't.

To a human observer, these numbers appear indeed random. There are no short repeating sequences, and, at least to a human observer, they are completely random. However, given enough time and motivation, it is possible to discover the original seed, recreate the sequence, and guess the next number in the sequence.

Therefore, the methods discussed in this article probably should not be used to generate numbers that must be cryptographically secure.

As mentioned above, pseudo-random number generators (PRNGs) must be seeded so that they produce a different sequence each time they generate new random numbers. Keep in mind that no method is magical - these seemingly random numbers are generated using relatively simple algorithms and relatively simple arithmetic. By seeding a PRNG, you can start from a different point each time. If you don't seed, it will produce the same sequence of numbers every time.

In Ruby, the kernel #srand method can be called without parameters. It will select a random number seed based on time, process ID and sequence number. Just call srand anywhere at the beginning of your program and it will generate a different series of seemingly random numbers every time you run it. This method is called implicitly when the program starts and seeds the PRNG with the time and process ID (no sequence number).

Generating Numbers

Once the program is running and the kernel #srand is called implicitly or explicitly, the kernel #rand method can be called. This method is called without parameters and will return a random number from 0 to 1. In the past this number was usually scaled to the largest number you wished to generate, perhaps with a to_i call to convert it to an integer.

# Generate an integer from 0 to 10
puts (rand() * 10).to_i

However, if you use Ruby 1.9.x, Ruby makes things simpler. The Kernel#rand method can accept a single parameter. If this argument is a number of any type, Ruby will generate an integer from 0 to (exclusively) that number.

# Generate a number from 0 to 10
# In a more readable way
puts rand(10)

But what if you want to generate a number from 10 to 15? Typically, you would generate a number from 0 to 5 and add it to 10. However, Ruby makes it easier.

You can pass a Range object to Kernel#rand and it does exactly what you would expect: generates a random integer in the range.

Be sure to pay attention to the scope of these two types. If you call rand(10..15), a number from 10 to 15, inclusive, will be generated. And rand(10...15) (with 3 points) will produce a number from 10 to 15, excluding 15.

# Generate a number from 10 to 15
# Including 15
puts rand(10..15)

Non-random random numbers

Sometimes you need a sequence of numbers that looks random, but you need to generate the same sequence every time. For example, if you are generating random numbers in a unit test, you should generate the same sequence of numbers every time.

A unit test that fails on one sequence should fail again the next time it is run, or it may not fail if it generates a different sequence the next time. To do this, call kernel #srand with a known constant value.

# Generate the same sequence of numbers every time
# the program is run
srand(5)
# Generate 10 random numbers
puts (0..10).map{rand(0..10)}

Note that the kernel #rand implementation is non-ruby. It does not abstract PRNG in any way, nor does it allow instantiation of PRNG. For PRNG, all code shares a global state. If you change the seed or otherwise change the state of the PRNG, the effects may be wider than you expect.

However, since the program expects the results of this method to be random (as that is its purpose), this may never be a problem. Only if the program expects to see an expected sequence of numbers, such as if it calls srand with a constant value, will it see an unexpected result.

The above is the detailed content of How Ruby generates random numbers. For more information, please follow other related articles on the PHP Chinese website!