pub struct Random { /* private fields */ }
Expand description
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§
source§impl Random
impl Random
sourcepub fn new() -> Result<Self, InitializeError>
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
.
sourcepub fn with_seed(seed: u32) -> Self
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();
sourcepub fn with_array_seed<T>(seed: T) -> Self
pub fn with_array_seed<T>(seed: T) -> 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();
sourcepub fn with_byte_array_seed(seed: [u8; 16]) -> Self
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();
sourcepub fn next_int32(&mut self) -> u32
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());
sourcepub fn next_real(&mut self) -> f64
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());
sourcepub fn fill_bytes(&mut self, dest: &mut [u8])
pub fn fill_bytes(&mut self, dest: &mut [u8])
Fill a buffer with bytes generated from the RNG.
This method generates random u32
s (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);
sourcepub fn seed(&self) -> &[u32]
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§
source§impl RngCore for Random
impl RngCore for Random
source§fn next_u64(&mut self) -> u64
fn next_u64(&mut self) -> u64
Generate next u64
output.
This function is implemented by generating two u32
s 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());
source§fn next_u32(&mut self) -> u32
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());
source§fn fill_bytes(&mut self, dest: &mut [u8])
fn fill_bytes(&mut self, dest: &mut [u8])
Fill a buffer with bytes generated from the RNG.
This method generates random u32
s (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);
source§fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>
Fill a buffer with bytes generated from the RNG.
This method generates random u32
s (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.
try_fill_bytes
is implemented with fill_bytes
and is infallible.
§Examples
use rand_core::{Error, RngCore};
use spinoso_random::Random;
let mut random = Random::with_seed(33);
let mut buf = [0; 32];
random.try_fill_bytes(&mut buf)?;
assert_ne!([0; 32], buf);
let mut buf = [0; 31];
random.try_fill_bytes(&mut buf)?;
assert_ne!([0; 31], buf);
§Errors
This method never returns an error. It is equivalent to calling the
infallible fill_bytes
method.
source§impl SeedableRng for Random
impl SeedableRng for Random
source§fn from_seed(seed: Self::Seed) -> Self
fn from_seed(seed: Self::Seed) -> Self
Reseed from four u32
s.
§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());
source§type Seed = [u8; 16]
type Seed = [u8; 16]
u8
arrays (we recommend [u8; N]
for some N
). Read moresource§fn seed_from_u64(state: u64) -> Self
fn seed_from_u64(state: u64) -> Self
u64
seed. Read moresource§fn from_rng<R>(rng: R) -> Result<Self, Error>where
R: RngCore,
fn from_rng<R>(rng: R) -> Result<Self, Error>where
R: RngCore,
Rng
. Read moresource§fn from_entropy() -> Self
fn from_entropy() -> Self
impl Eq for Random
impl StructuralPartialEq for Random
Auto Trait Implementations§
impl Freeze for Random
impl RefUnwindSafe for Random
impl Send for Random
impl Sync for Random
impl Unpin for Random
impl UnwindSafe for Random
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<R> Rng for R
impl<R> Rng for R
source§fn gen<T>(&mut self) -> Twhere
Standard: Distribution<T>,
fn gen<T>(&mut self) -> Twhere
Standard: Distribution<T>,
source§fn gen_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
fn gen_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
source§fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,
fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,
source§fn sample_iter<T, D>(self, distr: D) -> DistIter<D, Self, T>where
D: Distribution<T>,
Self: Sized,
fn sample_iter<T, D>(self, distr: D) -> DistIter<D, Self, T>where
D: Distribution<T>,
Self: Sized,
source§fn gen_bool(&mut self, p: f64) -> bool
fn gen_bool(&mut self, p: f64) -> bool
p
of being true. Read moresource§fn gen_ratio(&mut self, numerator: u32, denominator: u32) -> bool
fn gen_ratio(&mut self, numerator: u32, denominator: u32) -> bool
numerator/denominator
of being
true. I.e. gen_ratio(2, 3)
has chance of 2 in 3, or about 67%, of
returning true. If numerator == denominator
, then the returned value
is guaranteed to be true
. If numerator == 0
, then the returned
value is guaranteed to be false
. Read more