Trait rand::Rand

pub trait Rand {
    fn rand<R>(rng: &mut R) -> Self
    where
        R: Rng;
}

A type that can be randomly generated using an Rng.

Built-in Implementations

This crate implements Rand for various primitive types. Assuming the provided Rng is well-behaved, these implementations generate values with the following ranges and distributions:

• Integers (i32, u32, isize, usize, etc.): Uniformly distributed over all values of the type.
• char: Uniformly distributed over all Unicode scalar values, i.e. all code points in the range 0...0x10_FFFF, except for the range 0xD800...0xDFFF (the surrogate code points). This includes unassigned/reserved code points.
• bool: Generates false or true, each with probability 0.5.
• Floating point types (f32 and f64): Uniformly distributed in the half-open range [0, 1). (The Open01, Closed01, Exp1, and StandardNormal wrapper types produce floating point numbers with alternative ranges or distributions.)

The following aggregate types also implement Rand as long as their component types implement it:

• Tuples and arrays: Each element of the tuple or array is generated independently, using its own Rand implementation.
• Option<T>: Returns None with probability 0.5; otherwise generates a random T and returns Some(T).

Required methods

fn rand<R>(rng: &mut R) -> Self where
    R: Rng, 

Generates a random instance of this type using the specified source of randomness.

Loading content...

Implementations on Foreign Types

impl Rand for u64

fn rand<R>(rng: &mut R) -> u64 where
    R: Rng, 

impl Rand for usize

fn rand<R>(rng: &mut R) -> usize where
    R: Rng, 

impl<T> Rand for [T; 20] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 20] where
    R: Rng, 

impl<A, B, C, D, E, F> Rand for (A, B, C, D, E, F) where
    A: Rand,
    B: Rand,
    C: Rand,
    D: Rand,
    E: Rand,
    F: Rand, 

fn rand<R>(_rng: &mut R) -> (A, B, C, D, E, F) where
    R: Rng, 

impl<T> Rand for [T; 14] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 14] where
    R: Rng, 

impl<A, B, C, D, E, F, G, H, I, J, K> Rand for (A, B, C, D, E, F, G, H, I, J, K) where
    A: Rand,
    B: Rand,
    C: Rand,
    D: Rand,
    E: Rand,
    F: Rand,
    G: Rand,
    H: Rand,
    I: Rand,
    J: Rand,
    K: Rand, 

fn rand<R>(_rng: &mut R) -> (A, B, C, D, E, F, G, H, I, J, K) where
    R: Rng, 

impl Rand for isize

fn rand<R>(rng: &mut R) -> isize where
    R: Rng, 

impl<T> Rand for [T; 4] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 4] where
    R: Rng, 

impl<A, B, C, D, E> Rand for (A, B, C, D, E) where
    A: Rand,
    B: Rand,
    C: Rand,
    D: Rand,
    E: Rand, 

fn rand<R>(_rng: &mut R) -> (A, B, C, D, E) where
    R: Rng, 

impl<T> Rand for [T; 31] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 31] where
    R: Rng, 

impl<T> Rand for [T; 22] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 22] where
    R: Rng, 

impl<T> Rand for [T; 25] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 25] where
    R: Rng, 

impl<T> Rand for [T; 21] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 21] where
    R: Rng, 

impl Rand for i8

fn rand<R>(rng: &mut R) -> i8 where
    R: Rng, 

impl Rand for char

fn rand<R>(rng: &mut R) -> char where
    R: Rng, 

impl Rand for f32

fn rand<R>(rng: &mut R) -> f32 where
    R: Rng, 

Generate a floating point number in the half-open interval [0,1).

See Closed01 for the closed interval [0,1], and Open01 for the open interval (0,1).

impl<T> Rand for [T; 17] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 17] where
    R: Rng, 

impl<A, B, C, D, E, F, G, H, I> Rand for (A, B, C, D, E, F, G, H, I) where
    A: Rand,
    B: Rand,
    C: Rand,
    D: Rand,
    E: Rand,
    F: Rand,
    G: Rand,
    H: Rand,
    I: Rand, 

fn rand<R>(_rng: &mut R) -> (A, B, C, D, E, F, G, H, I) where
    R: Rng, 

impl<T> Rand for [T; 32] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 32] where
    R: Rng, 

impl<T> Rand for [T; 5] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 5] where
    R: Rng, 

impl Rand for bool

fn rand<R>(rng: &mut R) -> bool where
    R: Rng, 

impl<A, B, C, D> Rand for (A, B, C, D) where
    A: Rand,
    B: Rand,
    C: Rand,
    D: Rand, 

fn rand<R>(_rng: &mut R) -> (A, B, C, D) where
    R: Rng, 

impl<T> Rand for [T; 10] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 10] where
    R: Rng, 

impl Rand for i32

fn rand<R>(rng: &mut R) -> i32 where
    R: Rng, 

impl<T> Rand for Option<T> where
    T: Rand, 

fn rand<R>(rng: &mut R) -> Option<T> where
    R: Rng, 

impl<T> Rand for [T; 2] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 2] where
    R: Rng, 

impl<T> Rand for [T; 18] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 18] where
    R: Rng, 

impl<T> Rand for [T; 1] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 1] where
    R: Rng, 

impl<A, B, C, D, E, F, G> Rand for (A, B, C, D, E, F, G) where
    A: Rand,
    B: Rand,
    C: Rand,
    D: Rand,
    E: Rand,
    F: Rand,
    G: Rand, 

fn rand<R>(_rng: &mut R) -> (A, B, C, D, E, F, G) where
    R: Rng, 

impl<T> Rand for [T; 8] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 8] where
    R: Rng, 

impl<T> Rand for [T; 9] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 9] where
    R: Rng, 

impl<T> Rand for [T; 19] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 19] where
    R: Rng, 

impl<T> Rand for [T; 27] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 27] where
    R: Rng, 

impl Rand for i16

fn rand<R>(rng: &mut R) -> i16 where
    R: Rng, 

impl<T> Rand for [T; 3] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 3] where
    R: Rng, 

impl<T> Rand for [T; 11] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 11] where
    R: Rng, 

impl<T> Rand for [T; 0]

fn rand<R>(_rng: &mut R) -> [T; 0] where
    R: Rng, 

impl Rand for f64

fn rand<R>(rng: &mut R) -> f64 where
    R: Rng, 

Generate a floating point number in the half-open interval [0,1).

See Closed01 for the closed interval [0,1], and Open01 for the open interval (0,1).

impl<T> Rand for [T; 30] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 30] where
    R: Rng, 

impl<T> Rand for [T; 15] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 15] where
    R: Rng, 

impl<A, B, C, D, E, F, G, H> Rand for (A, B, C, D, E, F, G, H) where
    A: Rand,
    B: Rand,
    C: Rand,
    D: Rand,
    E: Rand,
    F: Rand,
    G: Rand,
    H: Rand, 

fn rand<R>(_rng: &mut R) -> (A, B, C, D, E, F, G, H) where
    R: Rng, 

impl<A, B, C, D, E, F, G, H, I, J> Rand for (A, B, C, D, E, F, G, H, I, J) where
    A: Rand,
    B: Rand,
    C: Rand,
    D: Rand,
    E: Rand,
    F: Rand,
    G: Rand,
    H: Rand,
    I: Rand,
    J: Rand, 

fn rand<R>(_rng: &mut R) -> (A, B, C, D, E, F, G, H, I, J) where
    R: Rng, 

impl<T> Rand for [T; 24] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 24] where
    R: Rng, 

impl<A> Rand for (A,) where
    A: Rand, 

fn rand<R>(_rng: &mut R) -> (A,) where
    R: Rng, 

impl<T> Rand for [T; 28] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 28] where
    R: Rng, 

impl<A, B> Rand for (A, B) where
    A: Rand,
    B: Rand, 

fn rand<R>(_rng: &mut R) -> (A, B) where
    R: Rng, 

impl Rand for i64

fn rand<R>(rng: &mut R) -> i64 where
    R: Rng, 

impl<T> Rand for [T; 23] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 23] where
    R: Rng, 

impl<T> Rand for [T; 6] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 6] where
    R: Rng, 

impl Rand for u16

fn rand<R>(rng: &mut R) -> u16 where
    R: Rng, 

impl Rand for u8

fn rand<R>(rng: &mut R) -> u8 where
    R: Rng, 

impl<T> Rand for [T; 29] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 29] where
    R: Rng, 

impl<T> Rand for [T; 16] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 16] where
    R: Rng, 

impl<T> Rand for [T; 26] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 26] where
    R: Rng, 

impl<T> Rand for [T; 12] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 12] where
    R: Rng, 

impl<A, B, C, D, E, F, G, H, I, J, K, L> Rand for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: Rand,
    B: Rand,
    C: Rand,
    D: Rand,
    E: Rand,
    F: Rand,
    G: Rand,
    H: Rand,
    I: Rand,
    J: Rand,
    K: Rand,
    L: Rand, 

fn rand<R>(_rng: &mut R) -> (A, B, C, D, E, F, G, H, I, J, K, L) where
    R: Rng, 

impl Rand for ()

fn rand<R>(&mut R) where
    R: Rng, 

impl<T> Rand for [T; 7] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 7] where
    R: Rng, 

impl<A, B, C> Rand for (A, B, C) where
    A: Rand,
    B: Rand,
    C: Rand, 

fn rand<R>(_rng: &mut R) -> (A, B, C) where
    R: Rng, 

impl<T> Rand for [T; 13] where
    T: Rand, 

fn rand<R>(_rng: &mut R) -> [T; 13] where
    R: Rng, 

impl Rand for u32

fn rand<R>(rng: &mut R) -> u32 where
    R: Rng, 

Loading content...

Implementors

impl Rand for ChaChaRng

fn rand<R>(other: &mut R) -> ChaChaRng where
    R: Rng, 

impl Rand for Exp1

fn rand<R>(rng: &mut R) -> Exp1 where
    R: Rng, 

impl Rand for StandardNormal

fn rand<R>(rng: &mut R) -> StandardNormal where
    R: Rng, 

impl Rand for Isaac64Rng

fn rand<R>(other: &mut R) -> Isaac64Rng where
    R: Rng, 

impl Rand for IsaacRng

fn rand<R>(other: &mut R) -> IsaacRng where
    R: Rng, 

impl Rand for Closed01<f32>

fn rand<R>(rng: &mut R) -> Closed01<f32> where
    R: Rng, 

impl Rand for Closed01<f64>

fn rand<R>(rng: &mut R) -> Closed01<f64> where
    R: Rng, 

impl Rand for Open01<f32>

fn rand<R>(rng: &mut R) -> Open01<f32> where
    R: Rng, 

impl Rand for Open01<f64>

fn rand<R>(rng: &mut R) -> Open01<f64> where
    R: Rng, 

impl Rand for XorShiftRng

fn rand<R>(rng: &mut R) -> XorShiftRng where
    R: Rng, 

Loading content...