Cookbooks
Rust
Chapter 3. Numbers
Generating random numbers

Rust:
Generating random numbers

How to:

Rust relies on external crates for random number generation, with rand being the most commonly used. To start generating random numbers, you’ll first need to add rand to your Cargo.toml file:

[dependencies]
rand = "0.8.5"

Next, you can generate random numbers using rand in your Rust code. Here’s an example of generating a random integer and a floating-point number:

use rand::{Rng, thread_rng};

fn main() {
    let mut rng = thread_rng();
    
    // Generate a random integer between 1 and 10
    let random_int: i32 = rng.gen_range(1..=10);
    println!("Random Integer: {}", random_int);
    
    // Generate a random floating-point number between 0.0 and 1.0
    let random_float: f64 = rng.gen::<f64>();
    println!("Random Float: {}", random_float);
}

Sample output might be:

Random Integer: 7
Random Float: 0.9401077112175732

Note that re-running the program will produce different values.

Deep Dive

Random number generation in Rust, facilitated through rand and its dependencies like getrandom, represents a broad abstraction over operating system facilities and algorithmic generators. Historically, randomness in computing has evolved from simple, predictable algorithms to complex, cryptographically secure methods. Rust’s approach encapsulates this evolution through its pluggable Rng trait, which can be backed by various generators according to the required randomness quality and performance.

For most applications, relying on rand and the system’s RNG provides a good balance between simplicity and entropy. However, for cryptographic applications, crates like rand defer to getrandom for seeding, which itself relies on OS-specific mechanisms (e.g., /dev/urandom on Unix-like systems), ensuring cryptographically secure randomness.

Alternatively, if you have specific needs unmet by rand, exploring other crates or implementing custom generators based on mathematical models could be a route. Nonetheless, for the vast majority of use cases, rand and its ecosystem provide robust solutions that are both efficient and straightforward to integrate into Rust applications.

Rounding numbers