Struct peroxide::macros::r_macro::SmallRng

pub struct SmallRng(_);

An RNG recommended when small state, cheap initialization and good performance are required. The PRNG algorithm in SmallRng is chosen to be efficient on the current platform, without consideration for cryptography or security. The size of its state is much smaller than for StdRng.

Reproducibility of output from this generator is however not required, thus future library versions may use a different internal generator with different output. Further, this generator may not be portable and can produce different output depending on the architecture. If you require reproducible output, use a named RNG. Refer to The Book.

The current algorithm is [Pcg64Mcg][rand_pcg::Pcg64Mcg] on 64-bit platforms with Rust version 1.26 and later, or [Pcg32][rand_pcg::Pcg32] otherwise. Both are found in the rand_pcg crate.

Examples

Initializing SmallRng with a random seed can be done using FromEntropy:

use rand::FromEntropy;
use rand::rngs::SmallRng;

// Create small, cheap to initialize and fast RNG with a random seed.
// The randomness is supplied by the operating system.
let mut small_rng = SmallRng::from_entropy();

When initializing a lot of SmallRng's, using thread_rng can be more efficient:

use std::iter;
use rand::{SeedableRng, thread_rng};
use rand::rngs::SmallRng;

// Create a big, expensive to initialize and slower, but unpredictable RNG.
// This is cached and done only once per thread.
let mut thread_rng = thread_rng();
// Create small, cheap to initialize and fast RNGs with random seeds.
// One can generally assume this won't fail.
let rngs: Vec<SmallRng> = iter::repeat(())
    .map(|()| SmallRng::from_rng(&mut thread_rng).unwrap())
    .take(10)
    .collect();

Trait Implementations

impl Debug for SmallRng

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

Formats the value using the given formatter.

impl Clone for SmallRng

fn clone(&self) -> SmallRng

Returns a copy of the value.

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

Performs copy-assignment from source.

impl SeedableRng for SmallRng

type Seed = <Mcg128Xsl64 as SeedableRng>::Seed

Seed type, which is restricted to types mutably-dereferencable 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 from_rng<R>(rng: R) -> Result<SmallRng, Error> where
    R: RngCore, 

Create a new PRNG seeded from another Rng.

default fn seed_from_u64(state: u64) -> Self

Create a new PRNG using a u64 seed.

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.

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

Fill dest entirely with random data.