Struct Rand32

pub struct Rand32 { /* private fields */ }

A PRNG producing a 32-bit output.

The current implementation is PCG-XSH-RR.

Implementations

impl Rand32

pub const DEFAULT_INC: u64 = 1_442_695_040_888_963_407u64

The default value for increment. This is basically arbitrary, it comes from the PCG reference C implementation: https://github.com/imneme/pcg-c/blob/master/include/pcg_variants.h#L284

pub fn new(seed: u64) -> Self

Creates a new PRNG with the given seed and a default increment.

pub fn new_inc(seed: u64, increment: u64) -> Self

Creates a new PRNG. The two inputs, seed and increment, determine what you get; increment basically selects which sequence of all those possible the PRNG will produce, and the seed selects where in that sequence you start.

Both are arbitrary; increment must be an odd number but this handles that for you

pub fn state(&self) -> (u64, u64)

Returns the internal state of the PRNG. This allows you to save a PRNG and create a new one that will resume from the same spot in the sequence.

pub fn from_state(state: (u64, u64)) -> Self

Creates a new PRNG from a saved state from Rand32::state(). This is NOT quite the same as new_inc() because new_inc() does a little extra setup work to initialize the state.

pub fn rand_u32(&mut self) -> u32

Produces a random u32 in the range [0, u32::MAX].

pub fn rand_i32(&mut self) -> i32

Produces a random i32 in the range [i32::MIN, i32::MAX].

pub fn rand_float(&mut self) -> f32

Produces a random f32 in the range [0.0, 1.0).

pub fn rand_range(&mut self, range: Range<u32>) -> u32

Produces a random within the given bounds. Like any Range, it includes the lower bound and excludes the upper one.

This should be faster than Self::rand() % end + start, but the real advantage is it’s more convenient. Requires that range.end <= range.start.

Trait Implementations

impl Clone for Rand32

fn clone(&self) -> Rand32

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Rand32

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

Formats the value using the given formatter.

impl PartialEq for Rand32

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

impl Eq for Rand32

impl StructuralPartialEq for Rand32

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: 16 bytes