omnizip 0.3.24 → 0.3.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0119d9a2a28f5bc71cc0aa63f142b373196b8ca3f4abc0db93a71e0a9e45051
-  data.tar.gz: b3f6b837610a9005322e25dc5fd9d79a34529b9cd29d2c4d634efb3d64ad50fa
+  metadata.gz: 86505c60d041512f5f031bf20d19c4db6654ffe112bd0e885a7eb76129eaf37a
+  data.tar.gz: 8ceca40e4225c272bc527f508d231629b3357959e25e5f3b4ad50ba91116171f
 SHA512:
-  metadata.gz: dfa90d09bbe46eed96bec5565d1751e2bed9d47ee0e9a52b587c3cbad87aaf650e1083a4e8e9d3a22b7089ff0cf218386a2f55f637691f0de363d7646c114b3a
-  data.tar.gz: 5fecb94fb627f48411717bd7dcc4c9243f86b4030b4a24a951d8f0816a123e6ec7288cd4c6920e70a89fa0297e0d082389370341d4792d87985c6198ec7c2bbe
+  metadata.gz: 51953cf6f14aa679b99fe0abfc9fcc171addd943787ca7dde5b4f70945bf45ecad4dc2d7e72029f89495ba7e5c73ee9f8b72bcd8dcbe681812ef4038b7228328
+  data.tar.gz: 73407d59fc5dc1e4c6a8b997724101181c1650b8fff434b73cfa2a8835d643292fb192dcfe8a85baea49114cb5ae5cedd7c32f1e40d5e653b18b9d8f9ebd5a48

data/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.26] - 2026-08-26
+
+### Changed
+- BZip2 codec emits the **standard .bz2 wire format** (`BZh` magic,
+  bzip2 CRC-32, RLE1, BWT, seeded MTF, RUNA/RUNB RLE2, canonical
+  Huffman with the delta-coded length tables, 2..=6 selectable
+  groups, MSB-first bit packing, EOS magic + combined CRC). Output
+  is decodable by `bzip2 -d`; input from the CLI decodes here.
+  The previous internal byte-aligned container is removed.
+
+## [0.3.25] - 2026-08-26
+
+### Changed
+- BZip2 Burrows-Wheeler Transform: rotation comparator compares 4
+  big-endian bytes per step (Fixnum-safe, no modulo) over a doubled
+  byte array. 21x fewer allocations per 138 KB compressed, with
+  byte-identical output and 25 case-round-tripped correctness
+  (random and degenerate). The BZip2 codec itself does not emit a
+  standard bzip2 file format (pre-existing, separate issue).
+
 ## [0.3.24] - 2026-08-26
 
 ### Changed

data/lib/omnizip/algorithms/bzip2/bwt.rb

@@ -49,13 +49,16 @@ module Omnizip
           n = data.length
           bytes = data.bytes
 
+          # Doubled bytes: rotation a's byte at offset o is
+          # dbl[a + o] — indexing needs no modulo, and comparisons
+          # can run 8 bytes at a time (modulo arithmetic in the
+          # comparator dominated the encoder's profile).
+          dbl = bytes * 2
+
           # Build suffix array without creating rotation strings
-          # Use direct byte comparison for efficiency
           suffix_array = (0...n).to_a
-
-          # Sort using optimized comparison that avoids string allocation
           suffix_array.sort! do |a, b|
-            compare_rotations(bytes, a, b, n)
+            compare_rotations(dbl, a, b, n)
           end
 
           # Find primary index (position where suffix starts at 0)
@@ -63,7 +66,7 @@ module Omnizip
 
           # Extract last column (character before each suffix)
           transformed = suffix_array.map do |idx|
-            bytes[(idx - 1) % n]
+            dbl[n + idx - 1]
           end.pack("C*").b
 
           [transformed, primary_index]
@@ -149,23 +152,32 @@ module Omnizip
         # @param b [Integer] Second rotation start index
         # @param n [Integer] Length
         # @return [Integer] -1, 0, or 1 for comparison result
-        def compare_rotations(bytes, a, b, n)
-          # Fast path: compare first few bytes directly
-          8.times do |offset|
-            byte_a = bytes[(a + offset) % n]
-            byte_b = bytes[(b + offset) % n]
-            cmp = byte_a <=> byte_b
-            return cmp if cmp != 0
+        # Compare rotations a and b over the doubled byte array.
+        # Four big-endian bytes per step: the chunk fits a Fixnum (no
+        # Bignum allocation), the low-offset byte dominates so the
+        # order is lexicographic, and the doubled array removes the
+        # per-byte modulo.
+        def compare_rotations(dbl, a, b, n)
+          len = 0
+          while len + 4 <= n
+            wa = (dbl[a + len] << 24) |
+              (dbl[a + len + 1] << 16) |
+              (dbl[a + len + 2] << 8) |
+              dbl[a + len + 3]
+            wb = (dbl[b + len] << 24) |
+              (dbl[b + len + 1] << 16) |
+              (dbl[b + len + 2] << 8) |
+              dbl[b + len + 3]
+            return wa <=> wb if wa != wb
+
+            len += 4
           end
-
-          # Continue comparing remaining bytes
-          (8...n).each do |offset|
-            byte_a = bytes[(a + offset) % n]
-            byte_b = bytes[(b + offset) % n]
-            cmp = byte_a <=> byte_b
+          while len < n
+            cmp = dbl[a + len] <=> dbl[b + len]
             return cmp if cmp != 0
-          end
 
+            len += 1
+          end
           0
         end