bitvector 0.1.5

BitVector implementation in Rust
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

extern crate bitvector;
#[cfg(test)]
extern crate rand;

use bitvector::*;
use rand::distributions::Uniform;
use rand::Rng;
use std::collections::HashSet;

#[test]
fn fuzz_test() {
    let mut rng = rand::thread_rng();
    for _ in 0..5 {
        let v1: Vec<usize> = rng
            .sample_iter(Uniform::new(1, 10_000_000))
            .take(rng.gen_range(10, 10_000))
            .collect();
        let v2: Vec<usize> = rng
            .sample_iter(Uniform::new(1, 10_000_000))
            .take(rng.gen_range(10, 10_000))
            .collect();

        // reference hashset
        let r1 = v1.iter().cloned().collect::<HashSet<usize>>();
        let r2 = v2.iter().cloned().collect::<HashSet<usize>>();

        // bitvector
        let b1 = v1.iter().cloned().collect::<BitVector>();
        let b2 = v2.iter().cloned().collect::<BitVector>();

        // Step1. Check if collect::<BitVector>() works
        for i in 0..=b1.capacity() {
            assert_eq!(b1.contains(i), r1.contains(&i));
        }

        for i in 0..=b2.capacity() {
            assert_eq!(b2.contains(i), r2.contains(&i));
        }

        // STep2. Check if iter() works
        let v1_reconstruct = b1.iter().collect::<HashSet<usize>>();
        for i in 0..=b1.capacity() {
            assert_eq!(b1.contains(i), v1_reconstruct.contains(&i));
            assert_eq!(r1.contains(&i), v1_reconstruct.contains(&i));
        }
        let v2_reconstruct = b2.iter().collect::<HashSet<usize>>();
        for i in 0..=b2.capacity() {
            assert_eq!(b2.contains(i), v2_reconstruct.contains(&i));
            assert_eq!(r2.contains(&i), v2_reconstruct.contains(&i));
        }

        // Step 3.1 test union
        let mut u_b = b1.union(&b2).iter().collect::<Vec<usize>>();
        let mut u_r = r1.union(&r2).cloned().collect::<Vec<usize>>();
        u_b.sort();
        u_r.sort();
        assert_eq!(u_b, u_r);

        // Step 3.2 test intersection
        let mut u_b = b1.intersection(&b2).iter().collect::<Vec<usize>>();
        let mut u_r = r1.intersection(&r2).cloned().collect::<Vec<usize>>();
        u_b.sort();
        u_r.sort();
        assert_eq!(u_b, u_r);

        // Step 3.3 test difference
        let mut u_b = b1.difference(&b2).iter().collect::<Vec<usize>>();
        let mut u_r = r1.difference(&r2).cloned().collect::<Vec<usize>>();
        u_b.sort();
        u_r.sort();
        assert_eq!(u_b, u_r);
    }
}