Struct rand_isaac::isaac64::Isaac64Core[−][src]

[+] Show declaration

pub struct Isaac64Core { /* fields omitted */ }

[−]

The core of Isaac64Rng, used with BlockRng.

Implementations

`impl Isaac64Core`[src][−]

`pub fn new_from_u64(seed: u64) -> Self`[src][−]

👎 Deprecated since 0.6.0:

use SeedableRng::seed_from_u64 instead

Create an ISAAC-64 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 BlockRngCore for Isaac64Core`[src][+]

`type Item = u64`

Results element type, e.g. u32.

`type Results = IsaacArray<Self::Item>`

Results type. This is the ‘block’ an RNG implementing BlockRngCore generates, which will usually be an array like [u32; 16]. Read more

`fn generate(&mut self, results: &mut IsaacArray<Self::Item>)`[src][−]

Refills the output buffer, results. See also the pseudocode desciption of the algorithm in the Isaac64Rng documentation.

Optimisations used (similar to the reference implementation):

The loop is unrolled 4 times, once for every constant of mix().
The contents of the main loop are moved to a function rngstep, to reduce code duplication.
We use local variables for a and b, which helps with optimisations.
We split the main loop in two, one that operates over 0..128 and one over 128..256. This way we can optimise out the addition and modulus from s[i+128 mod 256].
We maintain one index i and add m or m2 as base (m2 for the s[i+128 mod 256]), relying on the optimizer to turn it into pointer arithmetic.
We fill results backwards. The reference implementation reads values from results in reverse. We read them in the normal direction, to make fill_bytes a memcopy. To maintain compatibility we fill in reverse.