Trait rand::Rand

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

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>(rng: &mut R) -> Self

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

Loading content...

Implementations on Foreign Types

impl Rand for isize

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

impl Rand for i8

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

impl Rand for i16

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

impl Rand for i32

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

impl Rand for i64

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

impl Rand for usize

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

impl Rand for u8

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

impl Rand for u16

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

impl Rand for u32

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

impl Rand for u64

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

impl Rand for f64

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

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 Rand for f32

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

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 Rand for char

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

impl Rand for bool

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

impl Rand for ()

fn rand<R: Rng>(_: &mut R)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> Rand for [T; 0]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading content...

Implementors

impl Rand for Exp1

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

impl Rand for StandardNormal

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

impl Rand for ChaChaRng

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

impl Rand for Closed01<f32>

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

impl Rand for Closed01<f64>

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

impl Rand for Isaac64Rng

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

impl Rand for IsaacRng

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

impl Rand for Open01<f32>

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

impl Rand for Open01<f64>

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

impl Rand for XorShiftRng

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

Loading content...