# [−] [src] Struct rand::rngs::StdRng

    pub struct StdRng(_);

The standard RNG. The PRNG algorithm in `StdRng` is chosen to be efficient on the current platform, to be statistically strong and unpredictable (meaning a cryptographically secure PRNG).

The current algorithm used is the ChaCha block cipher with either 20 or 12 rounds (see the `stdrng_*` feature flags, documented in the README). This may change as new evidence of cipher security and performance becomes available.

The algorithm is deterministic but should not be considered reproducible due to dependence on configuration and possible replacement in future library versions. For a secure reproducible generator, we recommend use of the rand_chacha crate directly.

## Trait Implementations

### `impl Clone for StdRng` [src]

#### `fn clone(&self) -> StdRng` [src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl Debug for StdRng` [src]

#### `fn fmt(&self, f: &mut Formatter) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl RngCore for StdRng` [src]

#### `fn next_u32(&mut self) -> u32` [src]

Return the next random `u32`. Read more

#### `fn next_u64(&mut self) -> u64` [src]

Return the next random `u64`. Read more

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

Fill `dest` with random data. Read more

#### `fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>` [src]

Fill `dest` entirely with random data. Read more

### `impl CryptoRng for StdRng` [src]

### `impl SeedableRng for StdRng` [src]

#### `type Seed = <Rng as SeedableRng>::Seed`

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

#### `fn from_seed(seed: Self::Seed) -> Self` [src]

Create a new PRNG using the given seed. Read more

#### `fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error>` [src]

Create a new PRNG seeded from another `Rng`. Read more

#### `fn seed_from_u64(state: u64) -> Self` [src]

Create a new PRNG using a `u64` seed. Read more

#### `fn from_entropy() -> Self` [src]

Creates a new instance of the RNG seeded via [`getrandom`]. Read more

## Auto Trait Implementations

### `impl Send for StdRng`

### `impl Sync for StdRng`

## Blanket Implementations

### `impl<R> Rng for R where
R: RngCore + ?Sized,` [src]

#### `fn gen<T>(&mut self) -> T where
Standard: Distribution<T>,` [src]

Return a random value supporting the [`Standard`] distribution. Read more

#### `fn gen_range<T: SampleUniform, B1, B2>(&mut self, low: B1, high: B2) -> T where
B1: SampleBorrow<T> + Sized,
B2: SampleBorrow<T> + Sized,` [src]

Generate a random value in the range [`low`, `high`), i.e. inclusive of `low` and exclusive of `high`. Read more

#### `fn sample<T, D: Distribution<T>>(&mut self, distr: D) -> T` [src]

Sample a new value, using the given distribution. Read more

####
ⓘImportant traits for DistIter<D, R, T>

### Important traits for DistIter<D, R, T>

`impl<D, R, T> Iterator for DistIter<D, R, T> where
D: Distribution<T>,
R: Rng, type Item = T;`
`fn sample_iter<T, D>(self, distr: D) -> DistIter<D, Self, T> where
D: Distribution<T>,
Self: Sized,` [src]

Create an iterator that generates values using the given distribution. Read more

#### `fn fill<T: AsByteSliceMut + ?Sized>(&mut self, dest: &mut T)` [src]

Fill `dest` entirely with random bytes (uniform value distribution), where `dest` is any type supporting [`AsByteSliceMut`], namely slices and arrays over primitive integer types (`i8`, `i16`, `u32`, etc.). Read more

#### `fn try_fill<T: AsByteSliceMut + ?Sized>(
&mut self,
dest: &mut T
) -> Result<(), Error>` [src]

Fill `dest` entirely with random bytes (uniform value distribution), where `dest` is any type supporting [`AsByteSliceMut`], namely slices and arrays over primitive integer types (`i8`, `i16`, `u32`, etc.). Read more

#### `fn gen_bool(&mut self, p: f64) -> bool` [src]

Return a bool with a probability `p` of being true. Read more

#### `fn gen_ratio(&mut self, numerator: u32, denominator: u32) -> bool` [src]

Return a bool with a probability of `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

### `impl<T> From<T> for T` [src]

#### `fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)` [src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<V, T> VZip<V> for T where
V: MultiLane<T>,` [src]

#### `fn vzip(self) -> V` [src]

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)