lineargen 0.1.0

Bit sequence generators based on LFSRs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

# Lineargen

`rand` compatible bit sequence generators
based on Galois linear feedback shift registers.

Due to the compatibility with `rand`, various kinds of
number sequences can be generated. One can also choose
elements from slices or shuffle them using the generated
bit sequence from the LFSR.

Note that LFSRs are extremely fast and easy to implement,
but their statistical properties might not always be the
best and they are definitely _not_ cryptographically
secure.

## Examples

Choose from elements in an array:

```rust
use rand::SeedableRng; // 0.8.5
use rand::seq::SliceRandom;
use lineargen::large::Linear128;

fn main() {
    let mut rng = Linear128::seed_from_u64(987654321);

    for _ in 0..100 { rng.clock(); }

    let my_data = ["foo", "bar", "baz", "qux"];

    // choose elements pseudorandomly
    for _ in 0..10 {
        println!("{}", my_data.choose(&mut rng).unwrap());
    }
}
```

Generate a sequence of `f32`:

```rust
use rand::prelude::*; // 0.8.5
use lineargen::Linear64;

fn main() {
    let mut rng = Linear64::seed_from_u64(0x5EED5EED5EED);

    for _ in 0..128 { rng.clock(); }

    for _ in 0..20 {
        let my_float: f32 = rng.gen();
        println!("{}", my_float);
    }
}

```

See how the LFSR actually works:

```rust
use rand_core::SeedableRng; // 0.6.4
use lineargen::Linear16;

fn main() {
    let mut rng = Linear16::seed_from_u64(1023);

    for _ in 0..50 {
        rng.clock();
        println!("{:016b}", rng.dump_state());
    }
}
```

## Reference

The LFSR taps were taken from:
[https://www.physics.otago.ac.nz/reports/electronics/ETR2012-1.pdf](https://www.physics.otago.ac.nz/reports/electronics/ETR2012-1.pdf).