Struct artichoke_backend::extn::core::random::Random

pub struct Random(_);

Implementations

impl Random

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

pub fn with_seed(seed: Option<u64>) -> Result<Self, Error>

pub fn with_array_seed(seed: Option<[u32; 4]>) -> Result<Self, Error>

pub fn bytes(&mut self, size: Int) -> Result<Vec<u8>, Error>

pub fn rand(&mut self, constraint: Max) -> Result<Rand, Error>

#[must_use]pub fn seed(&self) -> Int

Methods from Deref<Target = SpinosoRandom>

#[must_use]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

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

#[must_use]pub fn next_real(&mut self) -> f64

Generate next f64 output.

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

Examples

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

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);

#[must_use]pub const fn seed(&self) -> [u32; 4]

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

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

Trait Implementations

impl AsMut<Random> for Random

fn as_mut(&mut self) -> &mut SpinosoRandom

Performs the conversion.

impl AsRef<Random> for Random

fn as_ref(&self) -> &SpinosoRandom

Performs the conversion.

impl Clone for Random

fn clone(&self) -> Random

Returns a copy of the value.

pub 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() -> Random

Returns the "default value" for a type.

impl Deref for Random

type Target = SpinosoRandom

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Random

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Eq for Random

impl Hash for Random

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl PartialEq<Random> for Random

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralEq for Random

impl StructuralPartialEq for Random