Struct SmallRng 

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

A small-state, fast, non-crypto, non-portable PRNG

This is the “standard small” 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 small portable generator, use the rand_pcg or rand_xoshiro crate.)
• Non-cryptographic: output is easy to predict (insecure)
• Quality: statistically good quality
• Fast: the RNG is fast for both bulk generation and single values, with consistent cost of method calls
• Fast initialization
• Small state: little memory usage (current state size is 16-32 bytes depending on platform)

The current algorithm is Xoshiro256PlusPlus on 64-bit platforms and Xoshiro128PlusPlus on 32-bit platforms. Both are also implemented by the rand_xoshiro crate.

Seeding (construction)

This generator implements the SeedableRng trait. All methods are suitable for seeding, but note that, even with a fixed seed, output is not portable. Some suggestions:

1. To automatically seed with a unique seed, use rand::make_rng():

   use rand::rngs::SmallRng;
   let mut rng: SmallRng = rand::make_rng();

2. To use a deterministic integral seed, use seed_from_u64. This uses a hash function internally to yield a (typically) good seed from any input.

   let rng = SmallRng::seed_from_u64(1);

3. To seed deterministically from text or other input, use rand_seeder.

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 Clone for SmallRng

fn clone(&self) -> SmallRng

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SmallRng

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

Formats the value using the given formatter.

impl Eq for SmallRng

impl PartialEq for SmallRng

fn eq(&self, other: &SmallRng) -> 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 SmallRng

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: <SmallRng as SeedableRng>::Seed) -> SmallRng

Create a new PRNG using the given seed.

fn seed_from_u64(state: u64) -> SmallRng

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 StructuralPartialEq for SmallRng

impl TryRng for SmallRng

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, dest: &mut [u8]) -> Result<(), Infallible>

Fill dst entirely with random data.