Struct SmallRng 

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

Available on crate feature small_rng only.

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 SeedableRng::from_rng:

   use rand::SeedableRng;
   use rand::rngs::SmallRng;
   let rng = SmallRng::from_rng(&mut rand::rng());

   or SeedableRng::from_os_rng:

   let rng = SmallRng::from_os_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 generators implements RngCore and thus also Rng. 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

Formats the value using the given formatter.

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

fn next_u32(&mut self) -> u32

Return the next random u32.

fn next_u64(&mut self) -> u64

Return the next random u64.

fn fill_bytes(&mut self, dest: &mut [u8])

Fill dest with random data.

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: Self::Seed) -> Self

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

Create a new PRNG seeded from an infallible Rng.

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

where R: TryRngCore,

Create a new PRNG seeded from a potentially fallible Rng.

fn from_os_rng() -> Self

Creates a new instance of the RNG seeded via getrandom.

fn try_from_os_rng() -> Result<Self, Error>

Creates a new instance of the RNG seeded via getrandom without unwrapping potential getrandom errors.

impl Eq for SmallRng

impl StructuralPartialEq for SmallRng

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes