Trait rand::SeedableRng [] [src]

pub trait SeedableRng {
    type Seed: Sized + Default + AsMut<[u8]>;
    fn from_seed(seed: Self::Seed) -> Self;

    fn from_rng<R>(rng: R) -> Result<Self, Error>
        R: RngCore
, { ... } }

A random number generator that can be explicitly seeded.

This trait encapsulates the low-level functionality common to all pseudo-random number generators (PRNGs, or algorithmic generators).

The rand::FromEntropy trait is automatically implemented for every type implementing SeedableRng, providing a convenient from_entropy() constructor.

Associated Types

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

It is recommended to seed PRNGs with a seed of at least circa 100 bits, which means an array of [u8; 12] or greater to avoid picking RNGs with partially overlapping periods.

For cryptographic RNG's a seed of 256 bits is recommended, [u8; 32].

Implementing SeedableRng for RNGs with large seeds

Note that the required traits core::default::Default and core::convert::AsMut<u8> are not implemented for large arrays [u8; N] with N > 32. To be able to implement the traits required by SeedableRng for RNGs with such large seeds, the newtype pattern can be used:

use rand_core::SeedableRng;

const N: usize = 64;
pub struct MyRngSeed(pub [u8; N]);
pub struct MyRng(MyRngSeed);

impl Default for MyRngSeed {
    fn default() -> MyRngSeed {
        MyRngSeed([0; N])

impl AsMut<[u8]> for MyRngSeed {
    fn as_mut(&mut self) -> &mut [u8] {
        &mut self.0

impl SeedableRng for MyRng {
    type Seed = MyRngSeed;

    fn from_seed(seed: MyRngSeed) -> MyRng {

Required Methods

Create a new PRNG using the given seed.

PRNG implementations are allowed to assume that bits in the seed are well distributed. That means usually that the number of one and zero bits are about equal, and values like 0, 1 and (size - 1) are unlikely.

PRNG implementations are recommended to be reproducible. A PRNG seeded using this function with a fixed seed should produce the same sequence of output in the future and on different architectures (with for example different endianness).

It is however not required that this function yield the same state as a reference implementation of the PRNG given equivalent seed; if necessary another constructor replicating behaviour from a reference implementation can be added.

PRNG implementations should make sure from_seed never panics. In the case that some special values (like an all zero seed) are not viable seeds it is preferable to map these to alternative constant value(s), for example 0xBAD5EEDu32 or 0x0DDB1A5E5BAD5EEDu64 ("odd biases? bad seed"). This is assuming only a small number of values must be rejected.

Provided Methods

Create a new PRNG seeded from another Rng.

This is the recommended way to initialize PRNGs with fresh entropy. The FromEntropy trait provides a convenient from_entropy method based on from_rng.

Usage of this method is not recommended when reproducibility is required since implementing PRNGs are not required to fix Endianness and are allowed to modify implementations in new releases.

It is important to use a good source of randomness to initialize the PRNG. Cryptographic PRNG may be rendered insecure when seeded from a non-cryptographic PRNG or with insufficient entropy. Many non-cryptographic PRNGs will show statistical bias in their first results if their seed numbers are small or if there is a simple pattern between them.

Prefer to seed from a strong external entropy source like OsRng or from a cryptographic PRNG; if creating a new generator for cryptographic uses you must seed from a strong source.

Seeding a small PRNG from another small PRNG is possible, but something to be careful with. An extreme example of how this can go wrong is seeding an Xorshift RNG from another Xorshift RNG, which will effectively clone the generator. In general seeding from a generator which is hard to predict is probably okay.

PRNG implementations are allowed to assume that a good RNG is provided for seeding, and that it is cryptographically secure when appropriate.

Implementations on Foreign Types

impl<R> SeedableRng for BlockRng<R> where
    R: BlockRngCore + SeedableRng



impl<R> SeedableRng for BlockRng64<R> where
    R: BlockRngCore + SeedableRng