# Struct spinoso_random::Random

source · `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:

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

Create a RNG with a fixed seed:

```
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

source#### pub 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

```
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`

.

source#### pub fn with_seed(seed: u32) -> Self

#### pub fn with_seed(seed: u32) -> Self

Create a new random number generator using the given seed.

##### Examples

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

source#### pub fn with_array_seed<T>(seed: T) -> Selfwhere
T: IntoIterator<Item = u32>,
T::IntoIter: Clone,

#### pub fn with_array_seed<T>(seed: T) -> Selfwhere T: IntoIterator<Item = u32>, T::IntoIter: Clone,

Create a new random number generator using the given seed.

##### Examples

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

source#### pub 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

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

source#### pub 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

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

source#### pub 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

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

source#### pub 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

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

source#### pub 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

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

## Trait Implementations§

source§### impl PartialEq<Random> for Random

### impl PartialEq<Random> for Random

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

```
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

```
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

```
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

```
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

```
// 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]

#### 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 StructuralEq for Random

### impl StructuralPartialEq for Random

## Auto Trait Implementations§

### 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<R> Rng for Rwhere
R: RngCore + ?Sized,

### impl<R> Rng for Rwhere R: RngCore + ?Sized,

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