gf2 2.1.0

Working in bit-space a.k.a. GF(2)
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

#![doc = include_str!("../docs/gf2.md")]
// Enable unstable Rust features when the `unstable` feature is enabled.
// - The `BitArray` type requires simple arithmetic on const generic parameters.
// - Function traits lets us have the extra evaluation: `p(M)` for a bit-polynomial `p` and a bit-matrix `M`.
#![cfg_attr(feature = "unstable", feature(fn_traits))]
#![cfg_attr(feature = "unstable", feature(unboxed_closures))]
#![cfg_attr(feature = "unstable", feature(generic_const_exprs))]
#![cfg_attr(feature = "unstable", allow(incomplete_features))]

// Most foreign trait implementations for the concrete `BitStore` types are defined using macros to avoid code
// duplication. Some of the macros are also used by `BitMatrix` so need to be seen first.
// The macros themselves are not part of the public API.
#[macro_use]
mod store_traits;

// `Unsigned` is a trait for the primitive unsigned integer types that can back a bit-store.
pub mod unsigned;
pub use unsigned::Unsigned;

// `BitStore` is the core trait for `BitArray`, `BitVector`, and `BitSlice`.
pub mod store;
pub use store::BitStore;

// `BitArray` is a _statically sized_ array of bits --- a _bit-array_.
// We need  arithmetic on const generic parameters to implement `BitArray`, so gate it behind the `unstable` feature.
#[cfg(feature = "unstable")]
pub mod array;
#[cfg(feature = "unstable")]
pub use array::BitArray;

// `BitVector` is a _dynamically sized_ vector of bits --- a _bit-vector_.
pub mod vector;
pub use vector::BitVector;

// `BitSlice` is a non-owning view of a range of bits within any bit-store --- a _bit-slice_.
pub mod slice;
pub use slice::BitSlice;

// `Bits`, `SetBits`, `UnsetBits`, and `Words` iterators over any bit-store.
pub mod iterators;
pub use iterators::{
    Bits,
    SetBits,
    UnsetBits,
    Words,
};

// `BitPolynomial` is a polynomial over GF(2) --- a _bit-polynomial_.
pub mod polynomial;
pub use polynomial::BitPolynomial;

// `BitMatrix` is a _dynamically sized_ matrix of bits --- a _bit-matrix_.
pub mod matrix;
pub use matrix::BitMatrix;

// `BitGauss` is a Gaussian elimination solver for systems of linear equations over GF(2).
pub mod gauss;
pub use gauss::BitGauss;

// `BitLU` provides the LU decomposition for bit-matrices.
pub mod lu;
pub use lu::BitLU;

// `rng` is a helper module that needs to be visible but which exports nothing outside the crate.
// It provides a simple shared PRNG that is used to fill bit-stores and bit-matrices with random values.
mod rng;