Struct rand::IsaacRng

pub struct IsaacRng { /* fields omitted */ }

A random number generator that uses the ISAAC algorithm.

ISAAC stands for "Indirection, Shift, Accumulate, Add, and Count" which are the principal bitwise operations employed. It is the most advanced of a series of array based random number generator designed by Robert Jenkins in 1996[1][2].

Although ISAAC is designed to be cryptographically secure, its design is not founded in cryptographic theory. Therefore it is not recommended for cryptographic purposes. It is however one of the strongest non-cryptograpic RNGs, and that while still being reasonably fast.

Where fast random numbers are needed which should still be secure, but where speed is more important than absolute (cryptographic) security (e.g. to initialise hashes in the std library), a generator like ISAAC may be a good choice.

In 2006 an improvement to ISAAC was suggested by Jean-Philippe Aumasson, named ISAAC+[3]. But because the specification is not complete, there is no good implementation, and because the suggested bias may not exist, it is not implemented here.

Overview of the ISAAC algorithm:

(in pseudo-code)

Input: a, b, c, s[256] // state
Output: r[256]         // results

mix(a,i) = a ^ a << 13   if i = 0 mod 4
           a ^ a >>  6   if i = 1 mod 4
           a ^ a <<  2   if i = 2 mod 4
           a ^ a >> 16   if i = 3 mod 4

c = c + 1
b = b + c

for i in 0..256 {
    x = s_[i]
    a = f(a,i) + s[i+128 mod 256]
    y = a + b + s[x>>2 mod 256]
    s[i] = y
    b = x + s[y>>10 mod 256]
    r[i] = b
}

Numbers are generated in blocks of 256. This means the function above only runs once every 256 times you ask for a next random number. In all other circumstances the last element of the results array is returned.

ISAAC therefore needs a lot of memory, relative to other non-vrypto RNGs. 2 * 256 * 4 = 2 kb to hold the state and results.

References

[1]: Bob Jenkins, ISAAC: A fast cryptographic random number generator

[2]: Bob Jenkins, ISAAC and RC4

[3]: Jean-Philippe Aumasson, On the pseudo-random generator ISAAC

Methods

impl IsaacRng

pub fn new_unseeded() -> IsaacRng

Create an ISAAC random number generator using the default fixed seed.

pub fn new_from_u64(seed: u64) -> IsaacRng

Creates an ISAAC random number generator using an u64 as seed. If seed == 0 this will produce the same stream of random numbers as the reference implementation when used unseeded.

Trait Implementations

impl Clone for IsaacRng

fn clone(&self) -> IsaacRng

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for IsaacRng

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Rng for IsaacRng

fn next_u32(&mut self) -> u32

Return the next random u32.

fn next_u64(&mut self) -> u64

Return the next random u64.

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

Fill dest with random data.

fn next_f32(&mut self) -> f32

Return the next random f32 selected from the half-open interval [0, 1).

fn next_f64(&mut self) -> f64

Return the next random f64 selected from the half-open interval [0, 1).

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

Fill dest entirely with random data.

impl SeedableRng for IsaacRng

type Seed = [u8; 32]

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

fn from_seed(seed: Self::Seed) -> Self

Create a new PRNG using the given seed.

fn from_rng<R: Rng>(rng: R) -> Result<Self, Error>

Create a new PRNG seeded from another Rng.