vortex-data
diff --git a/‎Cargo.lock‎
Lines changed: 1 addition & 0 deletions b/‎Cargo.lock‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎vortex-buffer/Cargo.toml‎
Lines changed: 1 addition & 0 deletions b/‎vortex-buffer/Cargo.toml‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎vortex-buffer/src/bit/buf.rs‎
Lines changed: 116 additions & 0 deletions b/‎vortex-buffer/src/bit/buf.rs‎
Lines changed: 116 additions & 0 deletions
diff --git a/‎vortex-compute/benches/expand_buffer.rs‎
Lines changed: 23 additions & 14 deletions b/‎vortex-compute/benches/expand_buffer.rs‎
Lines changed: 23 additions & 14 deletions
@@ -43,6 +43,7 @@ workspace = true
 [dev-dependencies]
 arrow-buffer = { workspace = true }
 divan = { workspace = true }
+rstest = { workspace = true }
 
 [[bench]]
 name = "vortex_buffer"
 
@@ -406,6 +406,67 @@ impl BitBuffer {
     pub fn bitand_not(&self, rhs: &BitBuffer) -> BitBuffer {
         bitwise_binary_op(self, rhs, |a, b| a & !b)
     }
+
+    /// Iterate through bits in a buffer.
+    ///
+    /// # Arguments
+    ///
+    /// * `f` - Callback function taking (bit_index, is_set)
+    ///
+    /// # Panics
+    ///
+    /// Panics if the range is outside valid bounds of the buffer.
+    #[inline]
+    pub fn iter_bits<F>(&self, mut f: F)
+    where
+        F: FnMut(usize, bool),
+    {
+        let total_bits = self.len;
+        if total_bits == 0 {
+            return;
+        }
+
+        let is_bit_set = |byte: u8, bit_idx: usize| (byte & (1 << bit_idx)) != 0;
+        let bit_offset = self.offset % 8;
+        let mut buffer_ptr = unsafe { self.buffer.as_ptr().add(self.offset / 8) };
+        let mut callback_idx = 0;
+
+        // Handle incomplete first byte.
+        if bit_offset > 0 {
+            let bits_in_first_byte = (8 - bit_offset).min(total_bits);
+            let byte = unsafe { *buffer_ptr };
+
+            for bit_idx in 0..bits_in_first_byte {
+                f(callback_idx, is_bit_set(byte, bit_offset + bit_idx));
+                callback_idx += 1;
+            }
+
+            buffer_ptr = unsafe { buffer_ptr.add(1) };
+        }
+
+        // Process complete bytes.
+        let complete_bytes = (total_bits - callback_idx) / 8;
+        for _ in 0..complete_bytes {
+            let byte = unsafe { *buffer_ptr };
+
+            for bit_idx in 0..8 {
+                f(callback_idx, is_bit_set(byte, bit_idx));
+                callback_idx += 1;
+            }
+            buffer_ptr = unsafe { buffer_ptr.add(1) };
+        }
+
+        // Handle remaining bits at the end.
+        let remaining_bits = total_bits - callback_idx;
+        if remaining_bits > 0 {
+            let byte = unsafe { *buffer_ptr };
+
+            for bit_idx in 0..remaining_bits {
+                f(callback_idx, is_bit_set(byte, bit_idx));
+                callback_idx += 1;
+            }
+        }
+    }
 }
 
 impl<'a> IntoIterator for &'a BitBuffer {
@@ -419,6 +480,8 @@ impl<'a> IntoIterator for &'a BitBuffer {
 
 #[cfg(test)]
 mod tests {
+    use rstest::rstest;
+
     use crate::bit::BitBuffer;
     use crate::{ByteBuffer, buffer};
 
@@ -488,4 +551,57 @@ mod tests {
             "Buffer slices with different bits should not be equal (`PartialEq` needs `iter_padded()`)"
         );
     }
+
+    #[test]
+    fn test_slice_offset_calculation() {
+        let buf = BitBuffer::collect_bool(16, |_| true);
+        let sliced = buf.slice(10..16);
+        assert_eq!(sliced.offset(), 10);
+    }
+
+    #[rstest]
+    #[case(5)]
+    #[case(8)]
+    #[case(10)]
+    #[case(13)]
+    #[case(16)]
+    #[case(23)]
+    #[case(100)]
+    fn test_iter_bits(#[case] len: usize) {
+        let buf = BitBuffer::collect_bool(len, |i| i % 2 == 0);
+
+        let mut collected = Vec::new();
+        buf.iter_bits(|idx, is_set| {
+            collected.push((idx, is_set));
+        });
+
+        assert_eq!(collected.len(), len);
+
+        for (idx, is_set) in collected {
+            assert_eq!(is_set, idx % 2 == 0);
+        }
+    }
+
+    #[rstest]
+    #[case(3, 5)]
+    #[case(3, 8)]
+    #[case(5, 10)]
+    #[case(2, 16)]
+    fn test_iter_bits_with_offset(#[case] offset: usize, #[case] len: usize) {
+        let total_bits = offset + len;
+        let buf = BitBuffer::collect_bool(total_bits, |i| i % 2 == 0);
+        let buf_with_offset = BitBuffer::new_with_offset(buf.inner().clone(), len, offset);
+
+        let mut collected = Vec::new();
+        buf_with_offset.iter_bits(|idx, is_set| {
+            collected.push((idx, is_set));
+        });
+
+        assert_eq!(collected.len(), len);
+
+        for (idx, is_set) in collected {
+            // The bits should match the original buffer at positions offset + idx
+            assert_eq!(is_set, (offset + idx) % 2 == 0);
+        }
+    }
 }
@@ -3,21 +3,30 @@
 
 //! Expand benchmarks for `Buffer`.
 
-use divan::Bencher;
 use vortex_buffer::Buffer;
 use vortex_compute::expand::Expand;
 use vortex_mask::Mask;
 
+// buffer size, selectivity
+const PARAMETERS: &[(usize, f64)] = &[
+    (256, 0.1),
+    (256, 0.5),
+    (256, 0.9),
+    (1024, 0.1),
+    (1024, 0.5),
+    (1024, 0.9),
+    (4096, 0.1),
+    (4096, 0.5),
+    (4096, 0.9),
+    (16384, 0.1),
+    (16384, 0.5),
+    (16384, 0.9),
+];
+
 fn main() {
     divan::main();
 }
 
-const BUFFER_SIZE: usize = 1024;
-
-const SELECTIVITIES: &[f64] = &[
-    0.01, 0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90, 0.99,
-];
-
 fn create_test_buffer<T>(size: usize) -> Buffer<T>
 where
     T: Copy + Default + From<u8> + Send + 'static,
@@ -49,20 +58,20 @@ fn generate_mask(len: usize, selectivity: f64) -> Mask {
     Mask::from_iter(selection)
 }
 
-#[divan::bench(types = [u8, u32, u64], args = SELECTIVITIES, sample_count = 1000)]
-fn expand_selectivity<T: Copy + Default + From<u8> + Send + 'static>(
-    bencher: Bencher,
-    selectivity: f64,
+#[divan::bench(types = [u8, u32, u64], args = PARAMETERS, sample_count = 1000)]
+fn expand_buffer<T: Copy + Default + From<u8> + Send + 'static>(
+    bencher: divan::Bencher,
+    (buffer_size, selectivity): (usize, f64),
 ) {
     bencher
         .with_inputs(|| {
-            let mask = generate_mask(BUFFER_SIZE, selectivity);
+            let mask = generate_mask(buffer_size, selectivity);
             let true_count = mask.true_count();
             let buffer = create_test_buffer::<T>(true_count);
             (buffer, mask)
         })
-        .bench_values(|(buffer, mask)| {
-            let result = buffer.expand(&mask);
+        .bench_refs(|(buffer, mask)| {
+            let result = buffer.expand(mask);
             divan::black_box(result);
         });
 }