refactor: remove redundant computation (#29)

Context:
- Fixes a bug in headless_compress where this_size was not updated
dynamically per iteration.

Implemented:
- Made `this_size` be updated per iteration
- A unit test to ensure compression correctly handles inputs that do not
fit exactly into page sizes.

---------

Co-authored-by: Weixing Zhang <[email protected]>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: 3 people

src/rust/integer_compression/fastpfor.rs

@@ -30,10 +30,10 @@ impl Skippable for FastPFOR {
         output_offset: &mut Cursor<u32>,
     ) -> FastPForResult<()> {
         let inlength = helpers::greatest_multiple(input_length, self.block_size);
-        let pos = input_offset.position() as u32;
-        let final_inpos = pos + inlength;
+        let final_inpos = input_offset.position() as u32 + inlength;
         while input_offset.position() as u32 != final_inpos {
-            let this_size = std::cmp::min(self.page_size, final_inpos - pos);
+            let this_size =
+                std::cmp::min(self.page_size, final_inpos - input_offset.position() as u32);
             self.encode_page(input, this_size, input_offset, output, output_offset);
         }
         FastPForResult::Ok(())

tests/basic_tests.rs

@@ -376,3 +376,42 @@ fn test_random_numbers() {
         }
     }
 }
+
+#[test]
+fn test_fastpfor_headless_compress_unfit_pagesize() {
+    // The input size is a multiple of 128 but does not fit the page size
+    let test_input_size = 512 + BLOCK_SIZE_128;
+    let page_size = 512;
+
+    let input: Vec<u32> = (0..test_input_size).collect();
+    let mut output: Vec<u32> = vec![0; input.len()];
+    let mut decoded: Vec<u32> = vec![0; input.len()];
+    let mut input_offset = Cursor::new(0u32);
+    let mut output_offset = Cursor::new(0u32);
+
+    let mut codec = FastPFOR::new(page_size, BLOCK_SIZE_128);
+    codec
+        .compress(
+            &input,
+            input.len() as u32,
+            &mut input_offset,
+            &mut output,
+            &mut output_offset,
+        )
+        .expect("compression failed");
+
+    let compressed_len = output_offset.position() as usize;
+    input_offset.set_position(0);
+
+    codec
+        .uncompress(
+            &output,
+            compressed_len as u32,
+            &mut input_offset,
+            &mut decoded,
+            &mut Cursor::new(0u32),
+        )
+        .expect("decompression failed");
+
+    assert_eq!(input, decoded, "Input and decompressed data do not match");
+}