oxihuman-core 0.1.2

Core data structures, algorithms, and asset management for OxiHuman
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

// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0
#![allow(dead_code)]

pub struct BitsetFixed {
    pub words: Vec<u64>,
    pub len: usize,
}

pub fn new_bitset_fixed(len: usize) -> BitsetFixed {
    let words = len.div_ceil(64);
    BitsetFixed {
        words: vec![0u64; words.max(1)],
        len,
    }
}

pub fn bitset_set(b: &mut BitsetFixed, i: usize) {
    if i < b.len {
        b.words[i / 64] |= 1u64 << (i % 64);
    }
}

pub fn bitset_clear(b: &mut BitsetFixed, i: usize) {
    if i < b.len {
        b.words[i / 64] &= !(1u64 << (i % 64));
    }
}

pub fn bitset_get(b: &BitsetFixed, i: usize) -> bool {
    i < b.len && (b.words[i / 64] >> (i % 64)) & 1 == 1
}

pub fn bitset_flip(b: &mut BitsetFixed, i: usize) {
    if i < b.len {
        b.words[i / 64] ^= 1u64 << (i % 64);
    }
}

pub fn bitset_count_ones(b: &BitsetFixed) -> usize {
    b.words.iter().map(|w| w.count_ones() as usize).sum()
}

pub fn bitset_count_zeros(b: &BitsetFixed) -> usize {
    b.len - bitset_count_ones(b)
}

pub fn bitset_and(a: &BitsetFixed, b: &BitsetFixed) -> BitsetFixed {
    let len = a.len.min(b.len);
    let words = a
        .words
        .iter()
        .zip(b.words.iter())
        .map(|(x, y)| x & y)
        .collect();
    BitsetFixed { words, len }
}

pub fn bitset_or(a: &BitsetFixed, b: &BitsetFixed) -> BitsetFixed {
    let len = a.len.max(b.len);
    let aw = a.words.len();
    let bw = b.words.len();
    let max_w = aw.max(bw);
    let words = (0..max_w)
        .map(|i| {
            let av = if i < aw { a.words[i] } else { 0 };
            let bv = if i < bw { b.words[i] } else { 0 };
            av | bv
        })
        .collect();
    BitsetFixed { words, len }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn set_and_get() {
        /* set a bit then read it back */
        let mut b = new_bitset_fixed(64);
        bitset_set(&mut b, 7);
        assert!(bitset_get(&b, 7));
        assert!(!bitset_get(&b, 6));
    }

    #[test]
    fn clear_bit() {
        /* clear resets a previously set bit */
        let mut b = new_bitset_fixed(64);
        bitset_set(&mut b, 3);
        bitset_clear(&mut b, 3);
        assert!(!bitset_get(&b, 3));
    }

    #[test]
    fn count_ones() {
        /* popcount matches number of set bits */
        let mut b = new_bitset_fixed(16);
        bitset_set(&mut b, 0);
        bitset_set(&mut b, 5);
        assert_eq!(bitset_count_ones(&b), 2);
    }

    #[test]
    fn count_zeros() {
        /* zero count is complement of one count */
        let mut b = new_bitset_fixed(8);
        bitset_set(&mut b, 1);
        assert_eq!(bitset_count_zeros(&b), 7);
    }

    #[test]
    fn flip() {
        /* flip toggles a bit */
        let mut b = new_bitset_fixed(8);
        bitset_flip(&mut b, 4);
        assert!(bitset_get(&b, 4));
        bitset_flip(&mut b, 4);
        assert!(!bitset_get(&b, 4));
    }

    #[test]
    fn and_operation() {
        /* AND of two bitsets */
        let mut a = new_bitset_fixed(8);
        let mut bb = new_bitset_fixed(8);
        bitset_set(&mut a, 2);
        bitset_set(&mut a, 3);
        bitset_set(&mut bb, 3);
        let c = bitset_and(&a, &bb);
        assert!(!bitset_get(&c, 2));
        assert!(bitset_get(&c, 3));
    }

    #[test]
    fn or_operation() {
        /* OR of two bitsets */
        let mut a = new_bitset_fixed(8);
        let mut bb = new_bitset_fixed(8);
        bitset_set(&mut a, 0);
        bitset_set(&mut bb, 1);
        let c = bitset_or(&a, &bb);
        assert!(bitset_get(&c, 0));
        assert!(bitset_get(&c, 1));
    }

    #[test]
    fn out_of_bounds_ignored() {
        /* operations on out-of-bounds index are safe */
        let mut b = new_bitset_fixed(4);
        bitset_set(&mut b, 100);
        assert!(!bitset_get(&b, 100));
    }
}