Struct Random

pub struct Random { /* private fields */ }

Random provides an interface to Ruby’s pseudo-random number generator, or PRNG.

The PRNG produces a deterministic sequence of bits which approximate true randomness. The sequence may be represented by integers, floats, or binary strings.

The generator may be initialized with either a system-generated or user-supplied seed value.

PRNGs are currently implemented as a modified Mersenne Twister with a period of 2**19937-1.

This RNG reproduces the same random bytes and floats as MRI. It may differ when returning elements confined to a distribution.

Examples

Create an RNG with a random seed:

use spinoso_random::{Error, Random};

let mut random = Random::new()?;
let next = random.next_int32();

Create a RNG with a fixed seed:

use spinoso_random::Random;

let seed = 5489_u32;
let mut random = Random::with_seed(seed);
let rand = random.next_int32();

let seed = [627457_u32, 697550, 16438, 41926];
let mut random = Random::with_array_seed(seed);
let rand = random.next_int32();

Implementations

impl Random

pub fn new() -> Result<Self, InitializeError>

Create a new Mersenne Twister random number generator with a randomly generated seed.

This method initializes the Mersenne Twister random number generator with a seed derived from a cryptographically secure source of randomness.

Examples

use spinoso_random::{Error, Random};

let mut random = Random::new()?;
let next = random.next_int32();

Errors

If the randomness feature provided by the platform is not present or failed to completely generate a seed, an error is returned. This error should be raised as a Ruby RuntimeError.

pub fn with_seed(seed: u32) -> Self

Create a new random number generator using the given seed.

Examples

use spinoso_random::Random;

let seed = 33;
let mut random = Random::with_seed(seed);
let rand = random.next_int32();

pub fn with_array_seed<T>(seed: T) -> Self

where T: IntoIterator<Item = u32>, T::IntoIter: Clone,

Create a new random number generator using the given seed.

Examples

use spinoso_random::Random;

let seed = [1_u32, 2, 3, 4];
let mut random = Random::with_array_seed(seed);
let rand = random.next_int32();

pub fn with_byte_array_seed(seed: [u8; 16]) -> Self

Create a new random number generator using the given seed.

Examples

use spinoso_random::Random;

let seed = [1_u32, 2, 3, 4];
let mut random = Random::with_array_seed(seed);
let rand = random.next_int32();

pub fn next_int32(&mut self) -> u32

Generate next u32 output.

Generates a random number on (0..=0xffffffff)-interval.

u32 is the native output of the generator. This function advances the RNG step counter by one.

Examples

use spinoso_random::{Error, Random};

let mut random = Random::new()?;
assert_ne!(random.next_int32(), random.next_int32());

pub fn next_real(&mut self) -> f64

Generate next f64 output.

Generates a random number on [0,1) with 53-bit resolution.

Examples

use spinoso_random::{Error, Random};

let mut random = Random::new()?;
assert_ne!(random.next_real(), random.next_real());

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

Fill a buffer with bytes generated from the RNG.

This method generates random u32s (the native output unit of the RNG) until dest is filled.

This method may discard some output bits if dest.len() is not a multiple of 4.

Examples

use spinoso_random::{Error, Random};

let mut random = Random::new()?;
let mut buf = [0; 32];
random.fill_bytes(&mut buf);
assert_ne!([0; 32], buf);
let mut buf = [0; 31];
random.fill_bytes(&mut buf);
assert_ne!([0; 31], buf);

pub fn seed(&self) -> &[u32]

Returns the seed value used to initialize the generator.

This may be used to initialize another generator with the same state at a later time, causing it to produce the same sequence of numbers.

Examples

use spinoso_random::Random;

let seed = [1_u32, 2, 3, 4];
let random = Random::with_array_seed(seed);
assert_eq!(random.seed(), seed);

Trait Implementations

impl Clone for Random

fn clone(&self) -> Random

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Random

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

Formats the value using the given formatter.

impl Default for Random

fn default() -> Self

Returns the “default value” for a type.

impl From<&[u32]> for Random

fn from(seed: &[u32]) -> Self

Converts to this type from the input type.

impl From<[u32; 4]> for Random

fn from(seed: [u32; 4]) -> Self

Converts to this type from the input type.

impl From<[u8; 16]> for Random

fn from(seed: [u8; 16]) -> Self

Converts to this type from the input type.

impl From<u32> for Random

fn from(seed: u32) -> Self

Converts to this type from the input type.

impl Hash for Random

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Random

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

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

const 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 Random

fn next_u64(&mut self) -> u64

Generate next u64 output.

This function is implemented by generating two u32s from the RNG and shifting + masking them into a u64 output.

Examples

use rand_core::RngCore;
use spinoso_random::Random;

let mut random = Random::with_seed(33);
assert_ne!(random.next_u64(), random.next_u64());

fn next_u32(&mut self) -> u32

Generate next u32 output.

u32 is the native output of the generator. This function advances the RNG step counter by one.

Examples

use rand_core::RngCore;
use spinoso_random::Random;

let mut random = Random::with_seed(33);
assert_ne!(random.next_u32(), random.next_u32());

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

Fill a buffer with bytes generated from the RNG.

This method generates random u32s (the native output unit of the RNG) until dest is filled.

This method may discard some output bits if dest.len() is not a multiple of 4.

Examples

use rand_core::RngCore;
use spinoso_random::Random;

let mut random = Random::with_seed(33);
let mut buf = [0; 32];
random.fill_bytes(&mut buf);
assert_ne!([0; 32], buf);
let mut buf = [0; 31];
random.fill_bytes(&mut buf);
assert_ne!([0; 31], buf);

impl SeedableRng for Random

fn from_seed(seed: Self::Seed) -> Self

Reseed from four u32s.

Examples

use rand_core::{RngCore, SeedableRng};
use spinoso_random::Random;

// Default MT seed
let seed = 5489_u128.to_le_bytes();
let mut mt = Random::from_seed(seed);
assert_ne!(mt.next_u32(), mt.next_u32());

type Seed = [u8; 16]

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

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 Random

impl StructuralPartialEq for Random