turborand

CI License Cargo Documentation

Fast random number generators.

turborand's internal implementations use Wyrand, a simple and fast generator but not cryptographically secure, and also ChaCha8, a cryptographically secure generator tuned to 8 rounds of the ChaCha algorithm in order to increase throughput considerably without sacrificing too much security, as per the recommendations set out in the Too Much Crypto paper.

Examples

```rust use turborand::prelude::*;

let rand = Rng::new();

if rand.bool() { println!("Success! :D"); } else { println!("Failure... :("); } ```

Sample a value from a list:

```rust use turborand::prelude::*;

let rand = Rng::new();

let values = [1, 2, 3, 4, 5];

let value = rand.sample(&values); ```

Generate a vector with random values:

```rust use turborand::prelude::*; use std::iter::repeat_with;

let rand = Rng::new();

let values: Vec<_> = repeat_with(|| rand.f32()).take(10).collect(); ```

no-std Compatibility

turborand can be exposed to no-std environments, however only with reduced capability and feature sets. There'll be no Default implementations, and no new() constructors, so Rng/ChaChaRng seeds must be provided by the user from whatever source available on the platform. Some TurboRand methods will also not be available unless the alloc feature is enabled, which necessitates having a global allocator.

Performance

Wyrand is a pretty fast PRNG, and is a good choice when speed is needed while still having decent statistical properties. Currently, the turborand implementation benches extremely well against similar rand algorithms. Below is a chart of the fill_bytes method performance, tested on Windows 10 x64 on an AMD Ryzen 1700 clocked at 3.7Ghz with 32GB RAM at 3066Mhz.

fill_bytes benchmark

For filling 2048 byte array buffers, turborand's Rng is able to do so in around 170-180ns, whereas SmallRng does it between 260-268ns, and Pcg64Mcg (the fastest PCG impl on 64bit systems) does it in 305-312ns.

u64 gen benchmark

For generating unbound u64 values, turborand and fastrand are equal in performance, which is expected given they both implement the Wyrand algorithm, consistently performing around 820-830ps for generating a u64 value. SmallRng performs around 1.16ns, while Pcg64Mcg is at 1.35ns.

Migrating between versions

Check out MIGRATION.md to get all the notes needed to migrate between major versions of turborand.

License

Licensed under either of

at your option.