bitrush-index 0.1.1

A serializable bitmap index library able to index millions values/sec on a single thread.
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use bitrush_index::{Bitmap, OZBCBitmap};
use rand::Rng;

#[test]
fn set_base() {
    let mut b0 = OZBCBitmap::new();
    let mut b1 = b0.clone();
    let values = [0, 1, 100, 100000, 99999, 2, 100001, 1000000];
    let values_ok = [0, 1, 100, 100000, 100001, 1000000];

    for val in values.iter() {
        b0.set(*val);
    }

    for val in values_ok.iter() {
        b1.set(*val);
    }

    assert_eq!(b0, b1);
}

#[test]
fn set_advanced() {
    let mut b0 = OZBCBitmap::new();
    let mut b1 = b0.clone();

    let mut rng = rand::thread_rng();
    let n = 100000;
    let mut last_val_ok: u32 = rng.gen::<u32>();
    b0.set(last_val_ok);
    b1.set(last_val_ok);

    for _i in 1..n {
        let val = rng.gen::<u32>();
        b0.set(val);
        if val > last_val_ok {
            b1.set(val);
            last_val_ok = val;
        }
    }

    assert_eq!(b0, b1);
}

#[test]
fn bitand_and_unroll() {
    let mut b0 = OZBCBitmap::new();
    let mut b1 = b0.clone();
    let values_0 = [0, 1, 100, 100000, 100009, 1000000, 1000100, 1060000];
    let values_1 = [
        1, 7, 9, 99999, 100000, 100001, 100101, 1060000, 1060001, 2060001,
    ];
    let values_and = [1, 100000, 1060000];

    for val in values_0.iter() {
        b0.set(*val);
    }

    for val in values_1.iter() {
        b1.set(*val);
    }

    let b_and = (&b0) & (&b1);
    let unrolled_values = b_and.unroll_bitmap();

    assert_eq!(unrolled_values, values_and);
}

#[test]
fn write_read_advanced() {
    let mut b0 = OZBCBitmap::new();

    let mut rng = rand::thread_rng();
    let n = 100000;
    let mut last_val_ok: u32 = rng.gen::<u32>();
    b0.set(last_val_ok);

    for _i in 1..n {
        let val = rng.gen::<u32>();
        if val > last_val_ok {
            b0.set(val);
            last_val_ok = val;
        }
    }

    let b1 = b0.clone();
    let mut buf: Vec<u8> = vec![0; b0.size()];
    let r_write = b0.write_to_buffer(&mut buf);
    assert!(r_write.is_ok());
    assert_eq!(r_write.unwrap(), buf.len());

    b0 = OZBCBitmap::new();
    let r_read = b0.read_from_buffer(&buf, true);
    assert!(r_read.is_ok());
    assert_eq!(b0, b1);
}