Struct StdRng 

pub struct StdRng(/* private fields */);

A strong, fast (amortized), non-portable RNG

This is the “standard” RNG, a generator with the following properties:

• Non-portable: any future library version may replace the algorithm and results may be platform-dependent. (For a portable version, use the chacha20 crate directly.)
• CSPRNG: statistically good quality of randomness and unpredictable
• Fast (amortized): the RNG is fast for bulk generation, but the cost of method calls is not consistent due to usage of an output buffer.

The current algorithm used is the ChaCha block cipher with 12 rounds. Please see this relevant rand issue for the discussion. This may change as new evidence of cipher security and performance becomes available.

Seeding (construction)

This generator implements the SeedableRng trait. Any method may be used, but note that seed_from_u64 is not suitable for usage where security is important. Also note that, even with a fixed seed, output is not portable.

Using a fresh seed direct from the OS is the most secure option:

let rng = StdRng::try_from_rng(&mut SysRng).unwrap();

Seeding via rand::make_rng() or rand::rng() may be faster:

let mut rng: StdRng = rand::make_rng();

Any SeedableRng method may be used, but note that seed_from_u64 is not suitable where security is required. See also Seeding RNGs in the book.

Generation

The generator implements Rng and thus also RngExt. See also the Random Values chapter in the book.

Trait Implementations

impl Debug for StdRng

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for StdRng

fn eq(&self, other: &StdRng) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SeedableRng for StdRng

type Seed = [u8; 32]

Seed type, which is restricted to types mutably-dereferenceable as u8 arrays (we recommend [u8; N] for some N).

fn from_seed(seed: <StdRng as SeedableRng>::Seed) -> StdRng

Create a new PRNG using the given seed.

fn seed_from_u64(state: u64) -> Self

Create a new PRNG using a u64 seed.

fn from_rng<R>(rng: &mut R) -> Self

where R: Rng + ?Sized,

Create a new PRNG seeded from an infallible Rng.

fn try_from_rng<R>(rng: &mut R) -> Result<Self, <R as TryRng>::Error>

where R: TryRng + ?Sized,

Create a new PRNG seeded from a potentially fallible Rng.

fn fork(&mut self) -> Self

where Self: Rng,

Fork this PRNG

fn try_fork(&mut self) -> Result<Self, Self::Error>

where Self: TryRng,

Fork this PRNG

impl TryRng for StdRng

type Error = Infallible

The type returned in the event of a RNG error.

fn try_next_u32(&mut self) -> Result<u32, Infallible>

Return the next random u32.

fn try_next_u64(&mut self) -> Result<u64, Infallible>

Return the next random u64.

fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Infallible>

Fill dst entirely with random data.

impl Eq for StdRng

impl StructuralPartialEq for StdRng

impl TryCryptoRng for StdRng