compressed-intvec 0.6.0

Space-efficient integer vectors with fixed-width, variable-length, and sequence-oriented encodings.
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

//! Integration tests for the `seq_vec!` and `sseq_vec!` macros.

use compressed_intvec::seq::{BESSeqVec, BESeqVec, LESeqVec, SSeqVec};
use compressed_intvec::{seq_vec, sseq_vec};

// --- Tests for seq_vec! macro (unsigned) ---

#[test]
fn test_seq_vec_macro_basic() {
    // Polymorphism: infers u32
    let v = seq_vec![[1u32, 2, 3], [4, 5], []];

    assert_eq!(v.len(), 3, "seq_vec! length mismatch");
    assert_eq!(
        v.get(0).unwrap().collect::<Vec<_>>(),
        vec![1, 2, 3],
        "seq_vec! first sequence"
    );
    assert_eq!(
        v.get(1).unwrap().collect::<Vec<_>>(),
        vec![4, 5],
        "seq_vec! second sequence"
    );
    assert!(
        v.get(2).unwrap().collect::<Vec<_>>().is_empty(),
        "seq_vec! third sequence should be empty"
    );
}

#[test]
fn test_seq_vec_macro_empty() {
    let v: LESeqVec<u32> = seq_vec![];
    assert_eq!(v.num_sequences(), 0, "seq_vec![] should have 0 sequences");
}

#[test]
fn test_seq_vec_macro_single_sequence() {
    let v: LESeqVec<u64> = seq_vec![[100, 200, 300]];
    assert_eq!(v.len(), 1, "Single sequence length");
    assert_eq!(
        v.get(0).unwrap().collect::<Vec<_>>(),
        vec![100, 200, 300],
        "Single sequence content"
    );
}

#[test]
fn test_seq_vec_macro_large_values() {
    let v: BESeqVec<u32> = seq_vec![[u32::MAX - 1, u32::MAX], [1000000, 2000000]];
    assert_eq!(v.len(), 2, "Large values length");
    assert_eq!(
        v.get(0).unwrap().collect::<Vec<_>>(),
        vec![u32::MAX - 1, u32::MAX],
        "Large values first sequence"
    );
}

#[test]
fn test_seq_vec_macro_with_trailing_comma() {
    let v: LESeqVec<u32> = seq_vec![[1, 2], [3, 4],];
    assert_eq!(v.len(), 2, "Trailing comma should not affect length");
    assert_eq!(
        v.get(0).unwrap().collect::<Vec<_>>(),
        vec![1, 2],
        "First sequence with trailing comma"
    );
}

// --- Tests for sseq_vec! macro (signed) ---

#[test]
fn test_sseq_vec_macro_basic() {
    let v: SSeqVec<i64> = sseq_vec![[-1, -2], [10, 20]];

    assert_eq!(v.len(), 2, "sseq_vec! length");
    assert_eq!(
        v.get(0).unwrap().collect::<Vec<_>>(),
        vec![-1, -2],
        "sseq_vec! first sequence"
    );
    assert_eq!(
        v.get(1).unwrap().collect::<Vec<_>>(),
        vec![10, 20],
        "sseq_vec! second sequence"
    );
}

#[test]
fn test_sseq_vec_macro_empty() {
    let v: SSeqVec<i64> = sseq_vec![];
    assert_eq!(v.num_sequences(), 0, "sseq_vec![] should have 0 sequences");
}

#[test]
fn test_sseq_vec_macro_mixed_values() {
    let v: SSeqVec<i64> = sseq_vec![[-100, -50, 0], [50, 100], [-1, -2, -3, -4]];

    assert_eq!(v.len(), 3, "Mixed values length");
    assert_eq!(
        v.get(0).unwrap().collect::<Vec<_>>(),
        vec![-100, -50, 0],
        "Mixed values first sequence"
    );
    assert_eq!(
        v.get(1).unwrap().collect::<Vec<_>>(),
        vec![50, 100],
        "Mixed values second sequence"
    );
    assert_eq!(
        v.get(2).unwrap().collect::<Vec<_>>(),
        vec![-1, -2, -3, -4],
        "Mixed values third sequence"
    );
}

        vec![-4, -3, -2, -1],
        "Mixed values third sequence"
    );
}

#[test]
fn test_seq_vec_signed_macro_single_sequence() {
    let v: LESSeqVec<i32> = seq_vec_signed![[-42, -21, 0, 21, 42]];
    assert_eq!(v.len(), 1, "Single signed sequence length");
    assert_eq!(
        v.get(0).unwrap().collect::<Vec<_>>(),
        vec![-42, -21, 0, 21, 42],
        "Single signed sequence content"
    );
}

#[test]
fn test_seq_vec_signed_macro_extreme_values() {
    let v: BESSeqVec<i64> = seq_vec_signed![[i64::MIN, i64::MIN + 1], [i64::MAX - 1, i64::MAX]];

    assert_eq!(v.len(), 2, "Extreme values length");
    let first = v.get(0).unwrap().collect::<Vec<_>>();
    assert!(first[0] < first[1], "First extreme sequence ordering");
}

#[test]
fn test_seq_vec_signed_macro_with_trailing_comma() {
    let v: LESSeqVec<i16> = seq_vec_signed![[-10, -5], [5, 10],];
    assert_eq!(v.len(), 2, "Trailing comma should not affect length");
}

// --- Cross-endianness tests to ensure macros work with both LE and BE ---

#[test]
fn test_seq_vec_macro_le_vs_be_consistency() {
    let sequences = vec![vec![1u32, 2, 3], vec![4, 5]];

    let vec_le: LESeqVec<u32> = LESeqVec::from_slices(&sequences).unwrap();
    let vec_be: BESeqVec<u32> = BESeqVec::from_slices(&sequences).unwrap();

    // Both should contain the same data
    let le_collected: Vec<Vec<u32>> = vec_le.iter().map(|s| s.collect()).collect();
    let be_collected: Vec<Vec<u32>> = vec_be.iter().map(|s| s.collect()).collect();

    assert_eq!(
        le_collected, be_collected,
        "LE and BE should have same content"
    );
    assert_eq!(le_collected, sequences, "Content should match original");
}