Function rng 

pub fn rng() -> Prng

Convenience constructor using system entropy.

Examples found in repository

examples/random_demo.rs (line 17)

fn basic_usage() {
    println!("Basic PRNG usage\n----------------");
    let mut prng = rng();
    println!("random u64   : {}", prng.next_u64());
    println!("range [10,20): {}", prng.random_range(10..20));
    println!("bool         : {}", prng.gen_bool());
}

fn normal_demo() {
    println!("Normal distribution\n-------------------");
    let mut prng = rng();
    for _ in 0..3 {
        let v = prng.normal(0.0, 1.0);
        println!("sample: {:.3}", v);
    }
}

fn shuffle_demo() {
    println!("Slice shuffling\n----------------");
    let mut prng = rng();
    let mut data = [1, 2, 3, 4, 5];
    data.shuffle(&mut prng);
    println!("shuffled: {:?}", data);

    let mut secure = crypto_rng();
    let byte = secure.random_range(0..256usize);
    println!("crypto byte: {}", byte);
}

examples/random_stats.rs (line 12)

fn chi_square_demo() {
    println!("Chi-square test on PRNG");
    let mut rng = rng();
    let mut counts = [0usize; 10];
    let samples = 10000;
    for _ in 0..samples {
        let v = rng.random_range(0..10usize);
        counts[v] += 1;
    }
    let expected = samples as f64 / 10.0;
    let chi2: f64 = counts
        .iter()
        .map(|&c| {
            let diff = c as f64 - expected;
            diff * diff / expected
        })
        .sum();
    println!("counts: {:?}", counts);
    println!("chi-square: {:.3}", chi2);
}

examples/game_of_life.rs (line 222)

pub fn generate_glider(board: &mut BoolMatrix, board_size: usize) {
    // Initialize with a Glider pattern.
    // It demonstrates how to set specific cells in the matrix.
    // This demonstrates `IndexMut` for `current_board[(r, c)] = true;`.
    let mut rng = rng();
    let r_offset = rng.random_range(0..(board_size - 3));
    let c_offset = rng.random_range(0..(board_size - 3));
    if board.rows() >= r_offset + 3 && board.cols() >= c_offset + 3 {
        board[(r_offset + 0, c_offset + 1)] = true;
        board[(r_offset + 1, c_offset + 2)] = true;
        board[(r_offset + 2, c_offset + 0)] = true;
        board[(r_offset + 2, c_offset + 1)] = true;
        board[(r_offset + 2, c_offset + 2)] = true;
    }
}

pub fn generate_pulsar(board: &mut BoolMatrix, board_size: usize) {
    // Initialize with a Pulsar pattern.
    // This demonstrates how to set specific cells in the matrix.
    // This demonstrates `IndexMut` for `current_board[(r, c)] = true;`.
    let mut rng = rng();
    let r_offset = rng.random_range(0..(board_size - 17));
    let c_offset = rng.random_range(0..(board_size - 17));
    if board.rows() >= r_offset + 17 && board.cols() >= c_offset + 17 {
        let pulsar_coords = [
            (2, 4),
            (2, 5),
            (2, 6),
            (2, 10),
            (2, 11),
            (2, 12),
            (4, 2),
            (4, 7),
            (4, 9),
            (4, 14),
            (5, 2),
            (5, 7),
            (5, 9),
            (5, 14),
            (6, 2),
            (6, 7),
            (6, 9),
            (6, 14),
            (7, 4),
            (7, 5),
            (7, 6),
            (7, 10),
            (7, 11),
            (7, 12),
        ];
        for &(dr, dc) in pulsar_coords.iter() {
            board[(r_offset + dr, c_offset + dc)] = true;
        }
    }
}