This provides no source of entropy in no_std mode; possibly
this should be fixed?

Courtesy of @pjhades
rust-random#163

…me new_from_rng → from_rng

(We have automatic derefs.)

Use a different technique to create floating point numbers uniformly distributed
over [0,1). The previous method only used 23 bits of precision for a f32, this
method uses all available 32 bits. This results in numbers with up to 9 bits of
precision extra when getting closer to zero.

`Closed01` and `Open01` used multiplication to adjust the range sampled from
`Uniform01`. This does not play well with an `Uniform01` that gets higher
precision as it gets closer to 0.0. `Closed01` now does it's own conversion to
sample from the range (0,1]. `Open01` uses the rejection method.

Changelog

Higher precision for floats in range [0,1)

See rust-lang/rfcs#2118 (comment)

… default impl

gen_bytes_* benchmarks show significant improvement, 8 - 68% over previous alg
(or 38% to 182% over algorithm before that)

…ack_box on all benches

Use of black_box has a huge effect (half performance in some cases, removes odd effects)

Benchmarks of OsRng show no significant change

This supports MyRng::new() using OsRng without requiring MyRng code to use OsRng.

Does not appear to impact performance

Also some TODO notes

Rationale: ReseedWithDefault required the RNG used to support Default, which
nothing other than StdRng supported. OTOH all RNGs support SeedFromRng which
gives them NewSeeded support too, and mock RNGs can support NewSeeded directly.

For into `isaac` and `isaac64` for easier comparison.
Split of `isaac_word` to generate correct the documentation (TODO).

Nothing is changed here, just split in three files.

This removes the unsafe blocks from the main isaac and isaac64 routines.
Some macro's are replaced by functions.
Over time the implementation of ISAAC and ISAAC-64 have diverged a bit, now they
are as similar as possible (for easier comparison).

The code is tested against the previous implementation, and the reference
implementation. IsaacRng now does 34% better in the benchmark.

…ing StdRng

This is a controvesial change. The argument *for* is that it prevents RNG
wrappers from accidentally implementing methods incorrectly via the default
impls (since it is valid to throw away bits, e.g. "self.next_u64() as u32",
this affects output, not just performance). The argument *against* is that it
complicates Rng implementations.

Also removed SeedableRng impl for IsaacWordRng: it's not reproducible across platforms

These changes make it possible to sample from closed ranges, not only from open.

Included is a small optimisation for the modulus operator, and an optimisation
for the types i8/u8 and i16/u16.

Allow sampling from a closed integer range

No reseeding

I have implemented it as a function instead of a trait, as that makes it easy to
add it to every RNG ont at a time.

I split the `init` function in two instead of the current version that uses a
bool to select between two paths. This makes it more clear how the seed is used.
The current `mix` macro has to be defined in the function, and would have to be
duplicated. Therefore I converted it to a seperate function.

I precalculated the values a...h, but am not sure this is a good idea. It makes
the resulting code smaller, and gives a small performance win. Because it are
'magic' values anyway, I thought why not?

Also moved the `impl_uint_from_fill` macro from `os.rs` to `randcore`. I had to
modify its error handling anyway, and it is shared with `OsRng`.

Error handling

Fix i128_support in range.rs

Add `new_from_u64` to `IsaacRng` and `Isaac64Rng`

So the internal state is never exposed (may be security-sensitive)

Common traits