VIREL: Verified Integer-Residual Encoding on Lattices for Exact and Error-Bounded Floating-Point Time-Series Compression Yue Zhang, Jiatao Lin, Haopeng Chen∗
arXiv:2607.22433v1 [cs.DB] 24 Jul 2026
Shanghai Jiao Tong University, Shanghai, China Email: {zhangyue20040611, 1169652042, chen-hp}@sjtu.edu.cn .
I. I NTRODUCTION
press adjacent-word XORs [1], [2]; ELF removes restorable mantissa suffixes before XOR coding [3], [4]; ALP maps decimal-compatible values to packed integers [5]; and Camel and DeXOR exploit decimal structure across adjacent values [6], [7]. These methods expose complementary facts. XOR and erasure exploit representation locality, while ALP-style integerization removes decimal conversion tails. What ALP leaves largely unused is the ordered time-series feature that the resulting decimal integers often have far smaller residuals than the original IEEE words. Recent integer-conversion codecs such as Ant and Falcon also show that floating-point values can be mapped to integer surrogates before delta or bit-plane coding [8], [9]. VIREL builds on this direction but makes the integer domain the CPU page codec’s temporal prediction domain. The hard case is mixed source resolution: one fine scale widens coarse integers, while literal exceptions break the coarse process’s predictive context. Error-bounded codecs face the same issue when a requested error lattice is much finer than the instrument’s source resolution. A second source of sparsity remains even after decimal alignment: physical sensors often move on a coarser sub-lattice, so integer increments such as +5 or +50 should be unit movements before prediction. We present V IREL (Verified Integer-Residual Encoding on Lattices). Its core is validated integer-lattice residual prediction. A numerical front end proposes an integer index qi and accepts it only after executing the decoder’s reconstruction and checking the active contract. V IREL-Exact requires raw-word equality; V IREL-EB requires pointwise absolute error at most ϵ. VIREL then predicts qi from preceding route-local integers and encodes ri = qi − qbi , (1)
Time-series systems store floating-point columns under two fidelity contracts. Archival and audit workloads require the original IEEE 754 words, including signed zeros and NaN payloads. Approximate analytics may instead trade a pointwise error bound for lower storage and transfer cost. Existing codecs typically implement these contracts with separate numerical representations, despite sharing the same temporal structure and page-processing requirements. Neither IEEE-word locality nor decimal scaling fully captures ordered floating point series. Gorilla and Chimp com-
instead of predicting or XORing the original IEEE word. Integerization is thus not merely a packing transform: it changes the domain of temporal modeling. Values that fail admission use an exact IEEE-word route. This admission rule is important: VIREL searches only a verified feasible domain, so decimal conversion, error-lattice selection, and divisor factoring cannot silently change the fidelity contract. To our knowledge, VIREL is the first CPU-oriented floating-point time-series codec to make this ALP-style decimal-integer view a route-persistent residual model and to evaluate it against
Abstract—Floating-point time-series compressors must exploit smooth consecutive values while surviving mixed precision, binary conversion tails, and unsmooth exceptions. Existing XOR codecs model IEEE words directly, whereas integerizing column codecs usually discard temporal continuity after conversion. We present V IREL (Verified Integer-Residual Encoding on Lattices), a CPU page-streamable framework that validates floating-point values on exact or error-bounded integer lattices, predicts the admitted integers, and compresses their residuals instead of adjacent IEEE words. To keep residuals small under mixed resolution, VIREL combines route-persistent multi-lane prediction with costed lattice-step normalization. The compression-first exact profile may encode the compact coordinate z for admitted integers satisfying q = dz + r; the error-bounded profile may encode q ′ = q/d only when d exactly divides a validated errorlattice index. Both transforms restore the same lattice point before reconstruction. Across canonical exact streams with independent 1,024value pages, V IREL-Exact-Fast reaches 6.0243×, while the compression-first V IREL-Exact-Upper reaches 7.0287× and emits 22.4% fewer bytes than the strongest evaluated exact SOTA baseline. On 74.70 million values in 48 independently paged streams, the two profiles reach 8.0629× and 9.6490×; the upper profile emits 27.48% fewer bytes than the strongest external baseline. At ϵ = 10−3 on 15 Serf streams, VIREL-EB reaches 12.1094×, emits 12.54% fewer bits than the strongest compliant errorbounded baseline, and preserves all pointwise bounds. Ablations show that removing integer-domain residual prediction increases exact output by 59.28%, and removing only q/d factoring loses 18.75% in the error-bounded setting. The exact implementation scales to 1,575/17,643 MB/s encode/decode at 32 cores and runs as an Apache TsFile page codec. Index Terms—floating-point compression, time-series compression, lossless compression, error-bounded compression, storage systems
XOR, erasure, decimal, GPU bit-plane, and error-bounded baselines under a common page protocol. Across our benchmarks, the strongest gains come from residual-coding these admitted integers, not from remaining in IEEE-word XOR space. That is why the paper focuses on route-local decimal residuals, then adds lattice-step normalization. Rather than computing one global GCD, V IRELExact-Upper discovers costed affine sub-lattices: for a lane satisfying q = dz+r, it stores the compact coordinate z instead of the sparse coordinate q. This removes source quantization steps before temporal prediction, so regular increments can become unit movements and then zero residuals. The claim is not that decimal scaling, integer deltas, bit packing, or secondary compression are individually new. Industrial storage engines expose configured scaled-integer paths [10], [11], ALP-like codecs pack decimal integers [5], and recent GPU codecs convert floats to integer surrogates [9]. The missing systems combination is the one VIREL studies: contractchecked numerical admission, lattice-step normalization, timeordered residual prediction in the admitted integer domain, route-local state for mixed resolution, and a page-streamable format with exact fallback. Mixed resolution is the main obstacle to this predictor. VIREL’s backend forms resolution-specific subsequences; the fast exact and error-bounded profiles use up to three lanes, while V IREL-Exact-Upper may use four cost-selected lattice lanes. A lane may be a scale lane or, in the compressionfirst exact profile, an affine sub-lattice lane q = dz + r. Each route retains its last two integers across intervening routes. A fine-resolution observation therefore updates only its own predictor and does not reset or widen the coarse subsequence. Within each lane, VIREL selects predictors per 16 values, ZigZag maps residuals, and chooses a base width by encoded cost. Rare wide residuals become sparse high-bit patches. The compression-first exact profile additionally lets a residual block choose Rice coding when its complete emitted cost is lower. This design makes mixed precision a routing problem rather than a block-wide exception penalty. The error-bounded front end applies the same lattice-step idea under a stricter reversibility rule. After validating a finelattice index q, it may encode q ′ = q/d only when d divides q. Decoding restores the identical q = q ′ d before floatingpoint reconstruction. The divisor exposes source resolution hidden by a fine requested error without spending additional error budget. Multiple divisor lanes then keep coarse and fine subsequences predictable instead of mixing them into one residual stream. Predictor state remains route-persistent across the resulting resolution lanes. VIREL buffers one bounded page, emits a self-contained bitstream, and releases its state. Pages are independently decodable and parallelizable. The production exact implementation offers a ratio profile and an α = 0 fast profile; a separate whole-column mode shares only entropy metadata and is used for mechanism studies. The error-bounded path reports the delta2-pruned profile as its throughput-oriented default; compression-oriented variants appear only in mechanism
studies under the same pointwise bound. Our results establish four findings. First, under independent 1,024-value pages on the canonical 14 streams, V IRELExact-Fast reaches 6.0243× and V IREL-Exact-Upper reaches 7.0287×; the upper profile emits 22.4% fewer bytes than Falcon’s GPU bit-plane pipeline and 40.2% fewer than the official DeXOR artifact. Second, on 74.70 million values in 48 independently encoded 1,024-value streams, V IREL-Exact-Fast reaches 8.0629× and V IREL-Exact-Upper reaches 9.6490×; the upper profile emits 48.34% fewer bytes than ELF* and 27.48% fewer than Falcon. Third, at ϵ = 10−3 on 15 Serf streams, the reporting error-bounded profile reaches 12.1094× and emits 12.54% fewer bits than Machete, the strongest of five compliant external baselines, with no observed bound violation, and reaches 164.56 MB/s encode throughput with 16 worker threads. Fourth, removing integer-domain residual prediction increases exact output by 59.28%; using one scale lane adds 7.45%, and resetting route state adds 4.11%. In error-bounded mode, removing only the q/d factoring step while retaining adaptive divisor routes loses 18.75% at 10−3 ; the full multi-resolution mechanism saves 19.44% at 10−3 and 36.86% at 10−6 . These ablations identify decimal/lattice residual prediction as the primary gain and routing as the mechanism that preserves it under mixed resolution. This paper makes the following contributions: • We systematically evaluate a representation-domain shift for CPU-oriented exact floating-point time series: after validated decimal/lattice admission, predicting source resolution integer residuals dominates the strongest evaluated CPU exact baselines under equal page resets. • We introduce costed lattice-step normalization. The compression-first exact profile discovers route-local affine sub-lattices q = dz + r and encodes the compact coordinate z only when complete frame cost decreases, removing physical quantization steps before residual coding. • We introduce route-persistent multi-lane prediction. Values are routed to compatible scale or lattice-step lanes, and each lane keeps its own temporal history across interruptions in the original stream. This preserves predictability under mixed precision and exceptions rather than treating them as global predictor resets. • We turn these mechanisms into a page-streamable codec with cost-selected predictors, sparse/Rice residual coding, bounded metadata containers, and an exact raw IEEE fallback for nonadmitted values. • We extend lattice-step normalization to error-bounded compression through costed divisor lanes: validated lattice indices are encoded as q ′ = q/d only when d divides q, predicted in separate lanes, and restored to the identical lattice point, so the transform uses no error budget. • We provide a unified verified evaluation across exact and error-bounded contracts, page, batch, and storageengine scopes, Falcon’s GPU bit-plane pipeline as a ratio baseline, 14 canonical streams, 48 larger streams, five compliant error-bounded baselines, component and robustness studies, equal-core scaling, and an Apache
TsFile page-codec integration. II. BACKGROUND AND P ROBLEM D EFINITION A. Representation gap A binary64 word contains one sign bit, an 11-bit biased exponent, and a 52-bit stored fraction [12]. XOR codecs exploit shared bits between nearby words. This representation, however, obscures how many time-series values are generated. A reading such as 12.4 lies on a scale-1 decimal lattice, yet its binary expansion has a long conversion tail. The tail is deterministic representation noise, not source precision. Integerization exposes this structure only when its reconstruction is defined. Multiplying by 10s may round or overflow, and dividing the resulting integer may produce a neighboring binary64 word. A configured decimal precision is therefore a storage policy, not a proof of losslessness. VIREL instead tests the exact reconstruction performed by the decoder. Scale and magnitude are orthogonal. The sequence 12.4, 1234.5, 12.5, 12.7 has one decimal scale; the magnitude jump requires a wider residual, not another representation. In 12.4, 1234.56789, 12.5, 12.7, the second value has a different source resolution. A single fine scale widens every integer, whereas a literal exception interrupts the coarse subsequence. Resolutionspecific routes avoid both costs. The same gap appears under an error bound. Let a requested step δ be finer than the sensor’s source step. The accepted lattice indices then share integer factors that are invisible in the reconstructed binary64 values. Removing such a factor is exact over the index if the decoder restores the identical index before floating-point reconstruction. B. Compression domains Modern analytical systems already distinguish value encoding from secondary byte compression, because the former determines which redundancy a query engine can exploit directly [13], [14]. Floating-point time-series codecs make the same representation choice at page granularity. Existing codecs operate primarily in three domains. IEEE-word codecs encode XOR or prediction residuals and exploit bitwise locality [1], [2]. Erasure codecs remove a restorable mantissa suffix before encoding the remaining word [3], [4]. Numerical codecs map values to decimal integers, decimal prefix/suffix fields, or quantized indices [5], [6], [7], [15]. VIREL combines numerical and temporal structure under the same correctness boundary. Its front end certifies an integer representation under the active fidelity contract. Its backend treats source resolution as a route, predicts each routed subsequence, and falls back to exact IEEE words. The page, rather than the tuple or complete column, is the planning and recovery unit. Table I locates the distinction. Existing methods attach state to the global value stream, an adjacent pair, or a vector. VIREL attaches state to a validated resolution route, allowing multiple logical numerical processes to remain continuous while their values interleave physically.
C. Contracts and execution scope For an ordered binary64 sequence X = ⟨x0 , . . . , xn−1 ⟩, exact mode requires ∀i,
bits(decode(encode(X))i ) = bits(xi ).
(2)
This includes signed zero and NaN payloads. Error-bounded mode receives a finite ϵ > 0 and requires ∀i with finite xi ,
|xi − x bi | ≤ ϵ,
(3)
while raw-routed values remain word-exact. This paper considers absolute error. We use frame, page, and batch with fixed meanings. A frame is the algorithmic coding unit: one set of route decisions, lane anchors, residual blocks, and length-delimited payloads. A page-scoped call emits one self-contained frame and is the deployment path used by the storage codec. A batch run contains multiple frames from a finite column under shared entropy metadata; it is used only where explicitly labeled. When an external artifact uses the word segment, we treat each segment as one independent page-scoped call. We call a codec page-streamable if it observes at most a fixed-size page before emission, uses page-bounded working memory, and permits page-local recovery. This is weaker than tuple-at-a-time streaming and stronger than wholecolumn batch compression. VIREL’s deployment path is pagestreamable; its optional exact batch mode only amortizes entropy metadata across pages. This scope matches TSDB and file-format execution paths, where chunk-local decoding, metadata, and scan operators are part of the storage contract [1], [10], [16], [11]. III. S YSTEM OVERVIEW Figure 1 shows the data path. Its defining step is to convert admissible floating-point values to validated decimal/lattice integers and then predict those integer residuals, not adjacent IEEE words. VIREL first executes one of two numerical admission contracts. Exact admission accepts a decimal scale only when integer reconstruction reproduces the input word. Bounded admission accepts an origin-relative lattice index only when the decoder’s binary64 reconstruction satisfies ϵ. Both emit integer indices plus an exact raw route. The shared backend then routes indices by source resolution, predicts each routed subsequence, and encodes the residuals. The decoder reads all decisions from the page; it performs no model search or membership test. A. Running example Consider the exact sequence 12.40, 12.42, 12.421337, 12.44. A single scale-6 representation produces integers near 12.4 million and widens the residuals of the three scale-2 values. Treating 12.421337 as a literal avoids that width but interrupts the adjacent-value predictor. VIREL instead forms two ordered subsequences: L2 = ⟨1240, 1242, 1244⟩,
L6 = ⟨12421337⟩.
TABLE I F LOATING - POINT TIME - SERIES DESIGN SPACE . “S TATE KEY ” IDENTIFIES WHICH HISTORY IS PRESERVED WHEN REPRESENTATIONS OR PRECISION CHANGE .
Method family Primary domain Gorilla/Chimp ELF family ALP DeXOR Serf VIREL
State key
Fidelity
Decision scope
IEEE-word XOR preceding/window value exact tuple/window erased IEEE word + XOR preceding erased value exact tuple decimal-scaled integer vector encoding exact + exceptions vector aligned decimal prefix/suffix adjacent pair exact tuple quantized delta or admissible IEEE word preceding value bounded error tuple/packet validated integer + raw IEEE source-resolution route exact or bounded page
COMPRESSION 1 binary64 page ordered values F ≤ 1024
2 validated admission Exact: RX (q, s) ≡ x EB: |x − RB (q)| ≤ ε
reject
3
4
resolution router
persistent predictor
residual framing
page assembly
route IDs + up to three integer lanes
lane-local history q̂i , ri = qi − q̂i
base width + bitmap + high-bit patches
local model metadata + framed payloads
raw IEEE/XOR lane
admission failures / non-finite values
PAGE BITSTREAM header / profile
route stream
lane metadata
residual blocks
raw XOR
DECOMPRESSION binary64 page original order exact or EB output
reconstruction
RX (q, s) or RB (q) under stored profile
route scatter
restore lanes
merge integer lanes and raw positions
replay predictor to recover each qi
residual/raw decoder unpatch residuals or restore XOR words
page parser read routes, models, and framed payloads
decoder replays stored decisions; no scale search or route inference
Fig. 1. VIREL moves temporal prediction into a validated integer residual domain. Both fidelity profiles feed the same route-persistent residual backend; values outside the domain use an exact raw XOR lane.
The route vector restores the original positions. Crucially, L2 retains the history 1240, 1242 while the L6 value is processed, so prediction of 1244 observes the logical scale-2 predecessor rather than the intervening high-precision value. In bounded mode, a fine step δ first yields a validated index q. If the source resolution makes q divisible by d, VIREL stores q ′ = q/d in a separate lane. This is not another quantization: decoding restores q = q ′ d before applying the reconstruction that already passed the error check. Figure 2 makes the complete transformation explicit. Validation first separates numerical structure from binary64 representation artifacts. Routing then preserves the temporal context of each source resolution, exposing the zero residual for 12.44 despite the intervening scale-6 value. The backend frames these integer residuals with a common base width and patches only exceptions. Decoding reverses the stored route and reconstruction decisions; it performs no numerical search. B. Design principles a) Predict after decimal/lattice admission.: IEEE conversion tails are deterministic representation artifacts. VIREL removes them through a validated integer mapping before
temporal prediction, so residuals describe numerical evolution at source resolution. b) Validate before compressing.: Integerization is accepted by reconstructing the value under the declared contract. The residual backend can therefore manipulate integers without weakening exactness or error guarantees. c) Route structure, not correctness.: The planner selects profile-bounded lanes only when their complete encoded cost, including route metadata, decreases. Uncovered values remain correct through the raw route. d) Keep state where continuity lives.: Predictor state belongs to a resolution route rather than to the global tuple stream. Interleaving changes output order but does not erase a lane’s temporal context. e) Bound the deployment unit.: All search and entropy statistics are page-local in the deployment path. Independent pages bound memory, isolate corruption, and expose parallel work to a storage engine. IV. D ESIGN A. Contract front ends and a shared backend V IREL separates numerical admission from integer-stream compression. A front end proposes profile parameters and
The predicate tests reconstruction rather than printed decimal text. Non-finite values, negative zero, overflow, and uncovered values use the raw route. The encoder retains observed minimum valid scales and greedily selects profile-bounded lanes using the deterministic complete-cost planner described below. The fast exact profile uses scale lanes directly: each covered value uses the lowest selected valid scale.
Validated generation mapping
1
xi
s
qi
12.40
2
1,240
route 0
12.42
2
1,242
0
12.421337
6
12,421,337
1
12.44
2
1,244
0
Admit only if bits(double(q)/10s ) = bits(x).
C. Exact lattice-step normalization The compression-first exact profile additionally searches affine sub-lattices inside admitted decimal scales. A lane descriptor (s, d, r) covers an admitted integer qs (x) when
Resolution-specific routing
2
tuple order
L2
1240
1242
12421337
0
0
1
1240
1242
1244
0
1244
L6 = ⟨12421337⟩; it does not reset L2 .
qs (x) = dz + r,
B = 16; choose α ∈ {−0.5, 0, 0.5} by encoded cost
qi
1240
1242
1244
input
anchor
1240
1240,1242
qî
anchor
anchor
1244
ri
anchor
anchor
0
The fine value is absent from this lane's state machine.
ZigZag residual base width w
anchors | 0 route
α
w
+ patch
exception bitmap center bits
patch
scatter route
RX (q, s)
inverse decode ri
restore lane
Prediction occurs after validation in the integer generation domain.
Fig. 2. VIREL’s exact data path for a mixed-precision sequence. Validated mapping yields generation integers and route IDs; route-persistent prediction recovers the scale-2 trend across the scale-6 value; fixed residual frames encode the result and provide a deterministic inverse path. Bounded mode uses the same backend after its error-bounded admission test.
a signed 64-bit index q, then evaluates its profile-specific binary64 reconstruction. Once admitted, q is the value seen by the temporal predictor; the original IEEE word no longer participates unless it takes the raw route. Exact mode uses RX (q, s) = fl(double(q)/10s ),
(4)
while error-bounded mode uses RB (o, q, δ) = fl(o + fl(qδ)) .
(5)
Both equations specify binary64 operations, not real-arithmetic shorthand; RB rounds the multiplication and addition separately. After admission, each front end emits integer lanes, a route vector, and an exact raw IEEE lane. The backend is identical: anchors, route-persistent prediction, residual widths, sparse patches, and canonical width codes. B. Exact decimal-generation front end For decimal scale s ∈ {0, . . . , 18}, V IREL-Exact proposes qs (x) = nearbyint(x10s ).
(6)
Its exact membership predicate is Es (x) ≡ finite(x10s ) ∧ qs (x) ∈ Z64 ∧ bits(RX (qs (x), s)) = bits(x).
(8)
and stores the compact coordinate z = (qs (x)−r)/d. A scaleonly lane is the special case d = 1, r = 0. Candidate divisors are generated from observed adjacent integer differences and their local greatest common divisors; for each divisor the most populated residue class is tested. The planner accepts such a lane only when the complete encoded frame cost decreases, including the descriptor and route bits. This is therefore not a global GCD pass: it is route-local, costed lattice-step normalization that removes physical quantization steps before residual prediction while remaining exactly invertible.
Prediction, framing, and reconstruction
3
0 ≤ r < d,
(7)
D. Checked error-lattice front end V IREL-EB receives a finite absolute bound ϵ > 0. For each frame it chooses the first finite nonzero value as origin o and evaluates three steps ∆(ϵ) = { nextafter(2ϵ, 0), nextafter(1.5ϵ, 0), nextafter(ϵ, 0)}.
(9)
For each δ, the encoder estimates (x − o)/δ in extended precision and tests nearby integer indices. It admits only a signed 64-bit q satisfying Qϵ (x; o, δ, q) ≡ finite(RB (o, q, δ)) ∧ |x − RB (o, q, δ)| ≤ ϵ.
(10)
The chosen q minimizes error among valid candidates; frame cost selects δ. This predicate accounts for binary64 evaluation rather than relying on a real-arithmetic half-step argument. Special values, signed zeros, overflow, and uncovered finite values use raw IEEE XOR. E. Lattice-step normalization in error-bounded mode A fine requested δ can make q unnecessarily large when the source was recorded at a coarser resolution. V IRELEB therefore searches a fixed alphabet D of 25 common binary/decimal divisors from 1 through 108 . An index may enter divisor lane d only if q mod d = 0, q ′ = q/d,
(11)
and the decoder checks that q ′ d fits in signed 64-bit arithmetic. The lane stores q ′ ; reconstruction restores q = q ′ d before evaluating Equation 5. Divisor routing changes residual magnitude, not the selected lattice point or its error.
1
the cheaper of an absolute value and a delta from the first. Subsequent values are partitioned into blocks of B = 16 and predicted as
Checked error-lattice indexing
ε = 10−3 , δ = 0.002, origin o = 12.4 xi
qi(0)
stored qi
RB
12.400
6200
0
12.400
12.500
6250
50
12.500
12.503
6252
52
12.504
12.600
6300
100
12.600
qbi (α) = qi−1 + round(α(qi−1 − qi−2 )) , α ∈ {−0.5, 0, 0.5}.
qi = qi(0) − 6200 = round((xi − o)/δ); every RB is checked.
2
Fine-lattice magnification +50
0
+2
50
+48
52
100
0.1/0.002 = 50 index units; magnitude width 6 → 1, ZigZag 7 → 2.
3
Exact routing and reconstruction
candidate: gcd(0, 50, 100) = 50; require q mod 50 = 0
(12)
The three choices represent half-delta reversal, previous value, and half-delta continuation. The fast exact profile fixes α = 0. Predictor state is indexed by route. If a fine-resolution observation occurs between two coarse observations, it updates only the fine lane. When the route returns, the coarse predictor resumes from its last two coarse integers. All histories reset at frame boundaries. Route persistence preserves each subsequence across interleaved values; a literal exception plus global restart does not.
select only when payload saving exceeds route + divisor metadata
0
50
52
100
0
0
1
0
L50
0
1
Δq ′ = 1
2
L1 = ⟨52⟩ because 52 mod 50 = 2.
page fields routes
L50 : 0, 1, 2
d = 50
multiply by d
route scatter
L1 : 52 RB = o + qδ
restored q: ⟨0, 50, 52, 100⟩ output: ⟨12.400, 12.500, 12.504, 12.600⟩
error: ⟨0, 0, 0.001, 0⟩ ≤ ε
Fig. 3. Exact source-resolution factoring in V IREL-EB. A fine lattice magnifies a 0.1 increment to 50 index units. Cost-selected d = 50 exposes unit residuals while index 52 remains in the d = 1 lane; decoding restores the identical validated indices.
For each δ, the planner first measures the implicit one-lane d = 1 representation. It also tests each divisor that covers the entire quantized lane, then greedily adds at most two partialcoverage divisors when complete frame cost decreases. If a value is divisible by several selected divisors, it is assigned to the largest such divisor. Lanes are reordered by decreasing frequency, breaking ties by larger divisor. A primary bitmap identifies nonprimary positions, followed only where needed by compact lane/raw route codes. This creates up to three resolution-specific subsequences while charging route metadata explicitly. Figure 3 traces this transform. For clarity, it first shows the absolute-grid indices obtained by dividing each value by δ; the implementation subtracts the page origin and stores the equivalent origin-relative indices. The fine error lattice turns a source increment of 0.1 into 50 integer units. Exact division by d = 50 recovers unit increments for the regular subsequence, while the nondivisible value remains in the d = 1 lane. The decoder multiplies by d before reconstruction, so factoring does not alter the checked lattice point. F. Route-persistent integer prediction Each selected lane is an ordered subsequence of signed integers. Its first two values are anchors; the second chooses
G. Base widths and sparse residual patches The signed residual ri = qi − qbi is ZigZag mapped to zi , whose bit length is ℓi . For each predictor, the encoder evaluates base widths drawn from the block’s distinct lengths, including zero. At width w, every normal residual uses w bits. A bitmap identifies values with ℓi > w; each patch stores a gammacoded width extension and its extension bits. The selected predictor/width minimizes C(α, w) = Cα (α) + Cw (w) + 1 + |B|w + ⊮[∃i : ℓi > w]|B| X + (Cγ (ℓi − w) + ℓi − w) ,
(13) (14) (15)
i:ℓi >w
where Cw is the current canonical Huffman length. The decision minimizes representation cost, not prediction error. A rare magnitude jump becomes a patch instead of widening the block. H. Frame planning A frame plan P is a selected set of lane descriptors plus the induced routes and lane streams. The encoder enumerates candidates in fixed order: exact scales s = 0, . . . , 18, affine descriptors (s, d, r) for V IREL-Exact-Upper, and, for V IRELEB, the δ candidates in Equation 9 followed by the divisor alphabet. It first validates all values, initializes the best onelane plan, and then greedily inserts lanes until the profile limit is reached: three for the fast exact and error-bounded profiles, and four for V IREL-Exact-Upper. Each trial rebuilds routes and lanes from scratch and is accepted only when the complete encoded cost C(P ; Λ) decreases strictly. This cost includes numerical metadata, route codes, anchors, predictor symbols, residual bases, patch metadata and payloads, raw payloads, frame lengths, and padding. Overlaps are resolved deterministically: exact scale-only candidates choose the lowest selected valid scale, exact affine candidates use a fixed descriptor order, and V IREL-EB chooses the largest selected divisor. Equal-cost candidates keep the incumbent. The first pass uses provisional width costs. The selected residual-width histogram defines canonical width-code lengths
Λ, after which the encoder performs one learned-cost reselection before emitting the frame. V IREL-EB lanes are ordered by decreasing frequency, then by larger divisor. The decoder reads the emitted routes, metadata, and payloads and performs no search. I. Raw IEEE fallback The raw lane is exact in both profiles. Its first word is literal; later words are XORed with the previous raw word. A zero XOR uses one control bit. A nonzero XOR stores a leading/trailing-zero window, reusing the previous window when its center is cheaper than declaring new 6-bit boundaries. The raw route makes lattice coverage a cost decision and preserves every IEEE bit pattern. J. Joint frame planning For an exact frame, the encoder discovers exact scales, optionally derives affine sub-lattice descriptors for the compression-first profile, runs the bounded planner with provisional width costs, builds a width alphabet from the selected blocks, and emits the route after one learned-cost reselection. For an error-bounded frame, it constructs validated q plans for all three δ candidates, runs the divisor planner for each candidate, learns width codes, and performs one refined and one final learned-cost selection. These are bounded passes, not an open convergence loop. The decoder performs no search: it expands stored lane integers, replays prediction, applies the recorded route, restores any affine or divisor-scaled coordinate, and reconstructs each value under the stream’s declared contract.
and bit-packed base/extension payloads. The three alphas use fixed codewords 0/10/11; the fast exact profile omits this field. Page-scoped runs place one header/model around one frame. The exact batch path may place multiple frames under a shared model, but frame payloads remain length-delimited for parallel decoding. B. Lossless backend reconstruction a) Integer lanes.: Each lane begins with explicit anchors. For every later value, encoder and decoder evaluate the same rounded integer predictor, invert the ZigZag code, and add the recovered residual. The base-width payload and sparse patches partition, but never discard, residual bits. Induction from the anchors therefore recovers every signed 64-bit lane integer. Signed and unsigned 128-bit intermediates detect an invalid overflow before narrowing. b) Routes and order.: The primary bitmap and optional route codes assign every frame position to exactly one integer lane or the raw lane. The format derives each lane’s value count from this route before decoding its length-delimited payload. Scattering the decoded subsequences by the same route restores tuple order. An invalid route symbol, payload count, or length is rejected rather than interpreted permissively. c) Raw IEEE values.: The first raw word is stored literally; each subsequent word is recovered by XORing its losslessly represented XOR residual with the preceding raw word. Because XOR is self-inverse, this path preserves all 64 bits, including signed zeros, subnormals, infinities, and NaN payloads. These properties are shared by the exact and errorbounded profiles.
V. F ORMAT AND C ORRECTNESS A. Profile headers and shared payloads
C. Profile fidelity guarantees
Exact and error-bounded streams carry distinct eight-byte magic values, so a decoder cannot silently apply the wrong numerical contract. Both headers store the value count, frame size, residual block size, frame count, and the canonical residual-width code lengths. An exact header identifies its scale profile. An error-bounded header stores the raw binary64 word of ϵ; the three δ values are deterministically regenerated by Equation 9. Every payload is length-delimited. A V IREL-Exact frame stores one to a profile-bounded number of lane descriptors, a route-presence flag and optional compact route, the integer lanes, and its raw XOR lane. A fast exact descriptor is a fivebit decimal scale. A compression-first exact descriptor also carries a gamma-coded divisor d and a fixed-width residue r; d = 1, r = 0 is the scale-only case. A V IREL-EB frame stores a two-bit δ identifier and 64-bit origin. Its common one-lane divisor-1 case is implicit; otherwise it stores a twobit lane count and five-bit divisor symbol per lane. A primary bitmap and compact exception codes route nonprimary and raw values. The subsequent integer-lane and raw-XOR payload formats are shared with exact mode. A residual block stores a prefix-coded α, a Huffman-coded base width, one patch-presence bit, an optional patch bitmap,
a) Exact profile.: For an integer-routed value, exact admission has already evaluated Equation 7 and established that RX (q, s) reproduces the input word. The backend recovers the stored lane coordinate. For a scale-only lane this coordinate is q; for an affine lane the decoder checks the descriptor and restores q = dz + r in signed 128-bit arithmetic before narrowing. The frame carries s, and the decoder executes the same binary64 reconstruction. Integer-routed values are therefore word-identical to their inputs. Raw-routed values are word-identical by the XOR path, and route scattering restores their original positions. Applying this argument independently to every frame gives the stream-level contract in Equation 2. b) Error-bounded profile.: Divisor routing is exact over the validated lattice index. Membership in a divisor lane requires Equation 11; after recovering q ′ , the decoder checks and computes q = q ′ d. It then uses the stored origin and deterministically regenerated δ to execute the same tworounding RB (o, q, δ) operation that passed Equation 10 at the encoder. Every lattice-routed finite value consequently satisfies the stored pointwise bound. The raw route has zero error for finite values and preserves bit patterns such as NaNs for which an ordered numerical error is not defined. Route scattering then establishes Equation 3 at the original positions.
D. Deterministic and defensive decoding The native targets disable floating-point contraction for reconstruction and force the multiplication and addition to materialize as binary64 operations. The decoder validates magic, sizes, frame counts, entropy symbols, lane, divisor, and residue bounds, route codes, residual widths, integer products, and trailing padding. It rejects malformed or truncated streams rather than returning a partial result. Tests cover all major IEEE classes, random high-entropy words, oscillation, mixed resolution, short streams, parallel/serial determinism, and truncation. VI. I MPLEMENTATION VIREL is implemented in C++20 behind C and Python APIs. The exact encoder stores scale membership in scalemajor arrays for all 19 scales and evaluates the three predictors in one history traversal. Candidate plans use estimated bit-cost analysis over routes, anchors, residual widths, patches, and raw payloads; only the winning route materializes a payload. The decoder uses a 64-bit buffered reader and scatters lane values directly to their output positions. Frame-local histories, routes, and patch state have bounded storage. The error-bounded front end estimates lattice indices in extended precision, then validates nearby candidates with the binary64 reconstruction in Equation 5. Compilation disables contraction, and materialized intermediates preserve the multiply-then-add sequence. A fixed 25-symbol divisor alphabet bounds metadata and search. The current planner caches divisor layouts and residual widths but reevaluates delta and route costs around two entropy passes; it is optimized for ratio rather than speed. The exact upper profile also admits Ricecoded residual blocks, selected by the same complete emittedcost rule as fixed-width residual blocks. A. Page and batch execution The page API accepts at most F = 1,024 values. It discovers representations, selects routes, builds a page-local width code, emits one self-contained frame, and releases all state. The official 1,000-value exact comparison uses the same path with F = 1,000. The large-corpus, TsFile, and primary error-bounded experiments use independent 1,024-value calls. An exact batch mode partitions a finite column into frames and shares one width alphabet across them. It retains input words and selected plans until a second emission pass, requiring O(n) memory. We use this mode only for controlled mechanism studies and cross-language ratio coverage. Neither mode is tuple-at-a-time because representation and residual selection require the current frame. B. Parallel execution Frames are independent once their lengths are known. Exact compression analyzes frames in parallel, constructs one entropy model, and emits fixed plans in a second parallel pass. Decompression scans frame lengths once and assigns frames to workers that write disjoint output ranges. The error-bounded API uses the same frame parallelism and is byte-identical
across thread counts, although its planner-heavy encoder scales less aggressively than the exact fast path. The implementation supports explicit worker counts. Evaluation uses a persistent worker pool; storage-engine deployment should share the database scheduler to avoid thread creation and preserve query-level resource control. C. Cost and memory Exact representation discovery performs at most 19 membership tests per value and validates only observed scale candidates in its second stage. With three lanes, three predictors, and B = 16, residual analysis is linear in frame size. Page encoding stores O(19F ) membership/index state; decoding uses O(F ) temporary state. The error-bounded planner remains O(F ) for its fixed three delta candidates and 25 divisors, but with a larger constant. Page working memory and latency are therefore bounded by F ; only exact batch execution adds O(n) state. VII. E VALUATION The evaluation answers five questions: Q1 How does VIREL’s ratio compare with exact and errorbounded floating-point codecs under equal resets? Q2 Which mechanisms produce the gain, and where do their bits go? Q3 Does the gain survive mixed precision, sparse sampling, temporal disorder, and larger real streams? Q4 What single-core cost does the exact profile incur, and how does page parallelism scale? Q5 Does the exact codec preserve its advantage inside a complete TsFile read/write path? A. Methodology The primary exact corpus is the 14-stream ELF/ELF* suite. Our files are byte-identical to the SElfStar artifact. Following its harness, codecs reset at every complete 1,000value page and discard tails, retaining 1,190,000 values (9.52 MB). Within-VIREL studies that encode complete columns (1,193,980 values) are used only to isolate mechanisms under one entropy scope. Table II separates page and batch evidence. Every crossmethod performance claim uses independent pages. Batch mode appears only in mechanism studies and a ratio-only comparison to Java artifacts. The C++ harness pins one thread to logical CPU 0 of an AMD EPYC 9554, performs one warm-up, and reports the median of three in-memory runs. Parsing and verification are excluded; output allocation is included. All methods use -O3 -mavx2. External baselines use the authors’ released artifacts or public repositories; we do not reimplement them for the reported rankings. Ratio is raw bytes divided by compressed bytes, and every method ranked as lossless passes a 64-bit word comparator. Unless stated otherwise, comparative tables mark the best value in bold and the second-best value with an underline; rows that fail the active fidelity contract are excluded from ranking.
TABLE II E XECUTION PROTOCOLS . PAGE - SCOPED RUNS EMIT EACH FRAME WITHOUT OBSERVING LATER VALUES ; BATCH RUNS SHARE ONE ENTROPY MODEL ACROSS A FINITE COLUMN .
Protocol
Encoding/model scope
Experiments
Claim supported
ELF exact reset independent 1,000-value page canonical 14, beta sweep published exact-codec comparison Production exact page independent 1,024-value page 48 streams, scaling, bit accounting bounded exact throughput Batch exact whole-column all frames in one finite column ablation, sensitivity, Java size exact mechanism and coverage Error-bounded equal reset independent 1,024-value page 15 streams, six error bounds EB ratio and pointwise error TsFile exact page path 1,024 values plus native metadata write, full/range scan, aggregate end-to-end storage path
B. Compression Effectiveness a) Exact compression on the canonical 14.: Each page is an independent codec call. Table III places the current exact VIREL profiles and exact baselines in one matrix. V IRELExact-Fast is the production ratio–speed profile; V IREL-ExactUpper adds compression-first Rice residual blocks and sparsehigh residual splits. Falcon is included as a ratio-only GPU baseline under the same complete-page reset. V IREL-ExactUpper is smallest on all 14 streams and reaches 7.0287× in aggregate. It emits 22.4% fewer bytes than Falcon and 40.2% fewer than DeXOR† . V IREL-Exact-Fast still reaches 6.0243× and is smaller than every strict non-VIREL CPU baseline in aggregate.
VIREL-EB VIREL-EB-1L Machete Serf-Qt
35
Serf-XOR SZ2 Sprintz
30
compression ratio
The large corpus contains 48 streams from UCI Household Power, Beijing Multi-Site Air Quality, UCI Appliances Energy, Microsoft GeoLife, and T-Drive: 74,697,728 values (569.9 MiB). Codecs reset every 1,024 values; source boundaries are frame-aligned and incomplete tails are discarded. A 1,024-value rerun of the canonical suite is the primary exact page result. With page-group metadata factoring, V IREL-Exact-Fast and V IREL-Exact-Upper reach 6.0243× and 7.0287×, respectively, compared with 5.4527× for Falcon, 4.2003× for the official DeXOR artifact, 4.1955× for ELF*, and 4.1911× for ALP. The ratio harness includes ELF, ELF*, ALP, Chimp, Gorilla, and Snappy; only CPU-hosted codecs enter throughput rankings. ELF+ and Camel are available only as Java artifacts and are not mixed into the page-ratio ranking. DeXOR is run from the official artifact; its decoded stream differs in 193,361 raw words under our bitwise checker, so its rows are marked and excluded from strict raw-word rankings. The DeXOR authors clarify that the released decoder does not access original values; their artifact validates with decimalplace tolerance to absorb binary–decimal rounding, whereas our strict checker counts raw IEEE-word differences. The error-bounded corpus contains 15 ordered columns from the Serf artifact. For each ϵ ∈ {10−1 , . . . , 10−6 }, VIREL-EB, Serf-Qt, Serf-XOR, SZ 2.1.6.2, Machete, and Sprintz-XFF reset at 1,024 values and process 1,750,016 values. Sizes charge complete output, including VIREL padding and Sprintz’s bound. SZ uses absolute bound 0.99ϵ; other methods receive ϵ. Every decoded value is checked against Equation 3.
25 20 15 10 5 10−1
10−2
10−3
10−4
absolute error bound ε
10−5
10−6
Fig. 4. Official delta2-pruned equal-reset error-bounded sweep over 1,750,016 values per setting. All plotted external methods satisfy the checked pointwise bound in all 90 dataset–error runs. VIREL-EB-1L is the single-resolution ablation.
b) Error-bounded compression.: Figure 4 reports the official delta2-pruned equal-reset sweep used for error-bound sensitivity and summary results. VIREL-EB has the highest aggregate ratio at all six bounds. At ϵ = 10−3 the reporting profile reaches 12.1094×. It compares with 10.5904× for Machete, 7.6294× for Serf-Qt, 6.6583× for Serf-XOR, 5.9587× for SZ2, and 3.5441× for Sprintz. The reporting profile therefore emits 12.54% fewer bits than the strongest compliant baseline and 37.00–70.73% fewer than the remaining four. Its maximum observed error is 10−3 , with no violation. Table VI compares throughput against external error-bounded codecs under the same bound. The VIREL-EB-1L-to-VIREL saving rises monotonically from 1.47% to 36.86% as ϵ tightens. A finer requested lattice increases exact factors in q without changing source resolution, directly matching Equation 11. Table IV separates exact divisor factoring from route isolation. NoFactor keeps the same adaptive divisor-route machinery and metadata, but stores the original lattice index q in each lane instead of q ′ = q/d. At ϵ = 10−3 , exact factoring alone reduces compressed size by 18.75% over this routed no-factor variant; routing without factoring recovers less than 1% over
TABLE III C ANONICAL -14 COMPRESSION RATIO WITH INDEPENDENT 1,024- VALUE PAGES ; HIGHER IS BETTER . ALP AND FALCON ARE SEPARATED AS GPU- BASED RATIO - ONLY BASELINES ; THEIR THROUGHPUT IS NOT COMPARED WITH CPU CODECS . † MARKS THE OFFICIAL D E XOR ARTIFACT WHEN REPORTED OUTSIDE STRICT RAW- WORD RANKING , AND ‡ MARKS FALCON ’ S SIGNED - ZERO RAW- WORD DIFFERENCES .
Method
CT
IR
WS
P10
SUK
USA
SDE
DT
AP
BW
BT
BP
BM
AS
Avg.
V IREL-Exact-Upper 9.6630 17.8664 12.3271 19.4747 13.2129 13.9766 13.0929 7.6972 6.3933 2.4945 4.0460 2.9947 5.0902 1.3586 7.0287 V IREL-Exact-Fast 9.0067 16.4757 11.5105 17.9183 9.8453 13.0759 9.3661 7.3314 6.1963 2.4392 2.5706 2.9690 4.2291 1.3297 6.0243 ELF ELF* Chimp Gorilla Snappy DeXOR†
4.8016 5.8840 1.5604 1.1736 2.7404 5.6418
6.4338 7.6885 1.5630 1.4311 3.0109 7.4094
5.0869 6.1039 1.2239 1.2073 3.1566 5.9242
8.4295 9.4201 2.3409 2.0819 4.3255 9.1460
5.4402 6.5236 1.9311 1.7524 2.8056 5.5101
5.6952 6.9259 1.5628 1.4786 2.8324 6.5692
4.5338 4.0714 3.9952 1.8295 1.9445 2.0955 2.7162 1.1761 3.6976 5.2226 4.7887 4.3124 1.9906 2.1458 2.3613 2.9743 1.2726 4.1955 1.4932 1.2904 1.5305 1.1414 1.1823 1.3067 1.3972 1.2945 1.4557 1.3929 1.1999 1.3957 1.0063 1.0602 1.2036 1.2714 1.2147 1.3153 2.6251 1.9181 1.3911 1.3740 1.7379 1.0274 1.6662 0.9994 2.1637 5.2236 4.8321 4.3055 2.0857 2.1866 2.4812 3.2820 1.2102 4.2003
bytes saved vs. VIREL-EB-1L (%)
GPU-based ratio-only baselines; throughput is not ranked against CPU codecs ALP 5.9958 6.7397 9.4450 7.0163 5.9118 7.0577 5.5284 5.1111 3.7854 2.0312 2.1460 2.4432 2.9706 1.2467 4.1911 Falcon‡ 8.1767 15.9042 11.3589 13.8209 8.9919 12.2474 8.8642 7.2088 6.0876 2.0909 2.1639 2.9125 4.0338 1.3427 5.4527 CT=City-temp, IR=IR-bio-temp, WS=Wind-Speed, P10=PM10-dust, SUK=Stocks-UK, USA=Stocks-USA, SDE=Stocks-DE, DT=Dew-point-temp, AP=Airpressure, BW=Basel-wind, BT=Basel-temp, BP=Bitcoin-price, BM=Bird-migration, AS=Air-sensor.
in 1,688, 19, and 2 frames, respectively, so most pages use the single-lane hot path while heterogeneous pages still receive isolated divisor lanes when their complete encoded cost decreases. With the same page-parallel runtime, the VIREL-EB reporting profile reaches 164.56 MB/s encode and 1161.68 MB/s decode on 16 cores without changing bytes. With 50-value packets and persistent Serf-XOR state, V IREL-EB reaches 9.3082× at 10−3 , versus 6.2250× for SerfQt and 7.4953× for tuned Serf-XOR, or 33.12% and 19.48% fewer bits. We use the equal-reset 1,024 experiment as primary because it gives every codec the same independence boundary.
40
30
20
10
0
10−1
10−2
10−3
10−4
absolute error bound ε
10−5
10−6
Fig. 5. Exact multi-resolution factoring saves increasingly more output as the requested error lattice becomes finer than the source resolution. TABLE IV D IVISOR FACTORING ABLATION UNDER THE OFFICIAL DELTA 2- PRUNED EB PROFILE . N O FACTOR ROUTES BY DIVISIBILITY BUT ENCODES ORIGINAL q RATHER THAN q/d; HIGHER RATIO IS BETTER .
ϵ −1
Full NoFactor
10 34.0313 10−2 17.5973 10−3 12.1094 10−4 9.2499 10−5 7.5508 10−6 6.5168
1L
Save
34.0295 33.5322 0.01% 16.3320 16.2593 7.19% 9.8388 9.7555 18.75% 6.7298 6.7014 27.24% 5.1002 5.0938 32.46% 4.1217 4.1146 36.75%
the one-lane stream. VIREL wins 12 of 15 columns against Machete and SerfQt, and all 15 against Serf-XOR, SZ2, and Sprintz. Machete is smaller on Air-pressure, Basel-wind, and TSBS longitude. Of 1,750,016 values, the delta2-pruned reporting profile stores 1,156,140 bytes. It selects one, two, and three lanes
C. Performance and Generalization a) Single-core throughput.: Table VII quantifies the ratio–speed trade-off. V IREL-Exact-Upper is the compression profile: scale and predictor search let it reach 7.0287× at 1.94 MB/s encode and 384.04 MB/s decode. V IREL-ExactFast keeps the same page format family but fixes the predictor to the previous integer, reaching 6.0243× at 39.30 MB/s encode and 924.61 MB/s decode. Falcon and ALP are reported only for size because the available measurements come from non-CPU paths; their encode/decode throughput is not ranked against CPU codecs. VIREL spends extra encode CPU on scale validation, routing, and residual-width planning, but storage systems often optimize for ratio and decode speed because they control read amplification, scan latency, cache pressure, and I/O. Among CPU baselines, V IREL-Exact-Fast gives the highest strict ratio and second-best decode speed, while V IREL-ExactUpper maximizes ratio. Encoding is page-parallel: the Fast core reaches 800.98 MB/s on 16 cores and 1,575.32 MB/s on 32 cores, so multi-core ingestion or compaction is unlikely to be encode-bound. b) Larger real streams.: Under the 1,024-value protocol, V IREL-Exact-Fast reaches 8.0629× and V IREL-Exact-Upper reaches 9.6490× on 74.70 million values. ELF* reaches 4.9851×, and the Falcon GPU bit-plane pipeline reaches
TABLE V P ER - COLUMN RATIO AT ϵ = 10−3 UNDER INDEPENDENT 1,024- VALUE RESETS . A LL METHODS SHOWN SATISFY THE CHECKED POINTWISE BOUND ; HIGHER IS BETTER . Method
AP
BT
BW
CD
CT
DT
IR
MT
P10
SG
USA
TD
LAT
LON
WS
Avg.
V IREL-EB 25.0717 7.0944 7.4835 9.3594 9.0462 7.0998 16.8549 10.3554 19.2287 16.9831 14.7565 17.5348 15.9079 15.5817 10.2781 12.1094 Serf-Qt 30.0703 3.6996 3.4224 7.6744 3.4491 3.7091 9.6999 8.1045 14.2581 13.3560 8.0279 18.9059 15.7640 15.7753 5.4980 7.6294 Serf-XOR 15.2174 3.9884 4.2363 5.9374 3.9924 4.6013 7.3750 6.9855 10.1237 9.3480 6.0169 11.7208 8.0209 8.5622 6.1073 6.6583 SZ2 18.4530 2.3734 5.8317 5.9227 3.3986 2.4738 8.3228 5.4829 10.1905 6.3544 8.2903 10.1731 11.0034 11.0330 4.0598 5.9587 Machete 25.2102 5.1314 8.9957 9.0928 6.4296 5.0725 15.0977 9.2680 17.3894 12.5616 13.6651 16.1917 15.6803 15.6921 8.7216 10.5904 Sprintz-XFF 5.1064 3.1053 2.5789 3.5189 2.6767 2.6498 3.5849 3.8423 4.3276 5.8813 3.5230 5.0889 3.5289 3.5299 3.3207 3.5441 AP=Air-pressure, BT=Basel-temp, BW=Basel-wind, CD=Chengdu-traj, CT=City-temp, DT=Dew-point-temp, IR=IR-bio-temp, MT=Motor-temp, P10=PM10dust, SG=Smart-grid, USA=Stocks-USA, TD=T-drive, LAT=TSBS latitude, LON=TSBS longitude, WS=Wind-Speed.
TABLE VI E RROR - BOUNDED THROUGHPUT AT ϵ = 10−3 IN MB/ S . VIREL-EB USES THE DELTA 2- PRUNED REPORTING PROFILE ; ALL ROWS SATISFY THE POINTWISE BOUND .
Ratio
Enc.
V IREL-EB 12.1094 34.21 1054.07 Machete 10.5904 165.80 1274.43 Serf-Qt 7.6294 297.70 378.49 Serf-XOR 6.6583 400.23 792.06 SZ2 5.9587 60.54 143.63 Sprintz-XFF 3.5441 286.97 363.32 TABLE VII AGGREGATE ONE - THREAD RESULTS ON THE CANONICAL 14. FALCON AND ALP ARE INCLUDED AS RATIO - ONLY NON -CPU BASELINES ; N/A THROUGHPUT CELLS ARE INTENTIONALLY NOT RANKED .
Method
ELF* ALP DeXOR
Dec.
compression ratio
Method
VIREL-Exact-Fast VIREL-Exact-Upper Falcon
10
1
1
3
6
9
12
15
18
decimal precision β
Ratio Comp. MB/s Decomp. MB/s
V IREL-Exact-Upper 7.0287 V IREL-Exact-Fast 6.0243 Falcon‡ 5.4527 ELF 3.6976 ELF* 4.1955 ALP 4.1911 Chimp 1.4557 Gorilla 1.3153 Snappy 2.1637 DeXOR† 4.2003
1.94 39.30 N/A 163.97 139.65 N/A 451.41 551.53 705.14 57.52
384.04 924.61 N/A 559.63 524.67 N/A 529.20 799.24 995.27 302.95
6.9973× under the same page reset. V IREL-Exact-Upper emits 48.34% fewer bytes than ELF* and 27.48% fewer than Falcon in aggregate. Against a per-stream oracle over ELF, ELF*, ALP, Chimp, Gorilla, and Falcon, V IREL-Exact-Fast wins 47 of 48 streams and V IREL-Exact-Upper wins all 48; the single Fast loss is Household-Voltage, where Falcon is 0.54% smaller. The result spans energy, air quality, building sensors, and mobility. The one-core aggregate throughput is 49.28/639.69 MB/s for V IREL-Exact-Fast and 2.46/355.01 MB/s for V IREL-ExactUpper, in compression/decompression order. ELF* reaches 151.29/606.76 MB/s. Falcon and ALP throughput measurements are not ranked against the CPU codecs. The larger suite preserves the ratio advantage and the per-core encoding cost. c) Decimal precision.: We extend the ELF/SElfStar TestBeta protocol from one Air-sensor column to a mixed
Fig. 6. Mixed canonical-14 compression ratio over all decimal precisions β ∈ [1, 18]. The logarithmic y-axis exposes both the low-precision gain and convergence at high precision.
canonical sweep. The experiment takes the first 5,000 decimal strings from each of the 14 exact datasets, truncates them to β = 1, . . . , 18, parses the result as binary64, and encodes the resulting 70,000 values with independent 1,000-value resets. Every VIREL, ELF*, and ALP output is raw-word exact. Figure 6 reports this mixed sweep with the current exact profiles, Falcon, ELF*, ALP, and DeXOR. V IRELExact-Upper is highest at every β: representative ratios are 33.9579× at β = 1, 5.7484× at β = 9, and 4.9449× at β = 18, versus 30.0429×, 4.8819×, and 4.2947× for Falcon and 15.2530×, 3.7629×, and 3.4368× for the strongest strict non-VIREL CPU baseline. The margin is largest where decimal residuals are narrow and contracts as conversion tails approach an incompressible binary64 mantissa. Falcon’s mixed-sweep mismatches are signed-zero only; DeXOR is measured descriptively but is not raw-word exact. D. Mechanism and Robustness a) Component ablation.: Table IX uses the same independent 1,024-value pages and page-group metadata container as the main exact result. Removing integer prediction causes the largest increase. The multi-lane mechanism has two parts:
TABLE VIII C OMPRESSION RATIO ON 74.70 MILLION REAL TIME - SERIES VALUES , GROUPED BY DOMAIN . FALCON IS A RATIO - ONLY GPU BASELINE . H IGHER IS BETTER .
Domain
Streams
Values V IREL-Exact-Fast V IREL-Exact-Upper
ELF*
Energy Air quality Building sensor Mobility
7 14,343,168 11 4,167,680 26 505,856 4 55,681,024
15.9092 11.4252 4.8439 7.0539
17.5695 13.1754 7.6817 13.3814 8.7598 6.3141 6.4120 1.7347 2.2481 8.5208 6.3137 4.5522
Aggregate
48 74,697,728
8.0629
9.6490
TABLE IX C OMPONENT ABLATION UNDER THE CURRENT EXACT PAGE / CONTAINER PROTOCOL . ∆ IS COMPRESSED - SIZE CHANGE RELATIVE TO V IREL -E XACT-U PPER ; LOWER IS BETTER .
Ratio ∆ bytes
Fast, no predictor 3.9361 +78.57% Fast, one lane 5.5630 +26.35% Fast, reset route state 5.8489 +20.17% V IREL-Exact-Fast 6.0243 +16.67% Upper, no sparse-high 6.6921 +5.03% Upper, no Rice 6.7213 +4.57% V IREL-Exact-Upper 7.0287 0.00%
it routes values to compatible scale/lattice lanes, and it keeps a separate temporal history for each lane across interruptions in the original stream. The one-lane ablation removes the routing capacity; the reset-state ablation keeps the selected routes but discards a lane history after route changes. Both increase size, showing that multi-lane compression is not just scale selection but route-persistent prediction. The sparse-high residual split is a smaller but consistent compression-first refinement, and Rice-pruned residual blocks provide the final compression-first gain. b) Bitstream accounting.: Writer instrumentation accounts for every emitted bit, including padding, and produces byte-identical streams. We apply it to 1,024-value resets of the canonical suite. The accounting is for the VIREL core page bitstream before the page-group secondary metadata container, because secondary compression does not preserve semantic bit categories. For V IREL-Exact-Upper, residual payloads consume 80.50% of the core stream; scale/route and predictor metadata consume 4.83% and 6.46%. Residual representation, not routing, is the dominant remaining cost. c) Batch: Mixed-precision exceptions.: The mixedprecision workload starts from the canonical 14 real timeseries columns. At each 1,024-value page, normal positions are rewritten through a scale-2 decimal ingestion path and selected exception positions through scale 6. Exceptions are either evenly interleaved or placed in one burst. Rates span 0–100%, with three seeds for interior rates. This preserves real temporal shape while controlling the precision mixture. We compare the two production VIREL profiles with Falcon, ELF*, ALP, and DeXOR. Falcon is a ratio-only CUDA baseline; the other three
6.9973 4.9851
TABLE X E XACT V IREL -E XACT-U PPER CORE OUTPUT DECOMPOSITION AT 1,024 VALUES PER RESET, BEFORE PAGE - GROUP SECONDARY COMPRESSION .
Category Variant
Falcon
Framing Scale and route Predictor metadata Patch metadata Normal residual Exception residual Raw fallback
Bits/value Stream share 0.1832 0.4762 0.6364 0.6182 7.0403 0.8887 0.0057
1.86% 4.83% 6.46% 6.28% 71.48% 9.02% 0.06%
are CPU exact-compression baselines. Figure 7 isolates a less synthetic workload than the earlier synthetic sanity check. On interleaved exceptions, V IRELExact-Fast decreases from 10.89× at 0% to 7.66× at 50%, while V IREL-Exact-Upper decreases from 11.81× to 8.54×; Falcon is 10.31× and 6.08×, respectively, and remains the strongest external baseline at those points. ELF*, ALP, and DeXOR all fall below 6.58× at 0% and 4.19× at 50%. Burst placement is slightly easier for all methods, with the same ordering. The result isolates the value of preserving a predictable state per precision lane without attributing the gain to a perfectly regular synthetic sequence. d) Batch: Sparse sampling and temporal disorder.: We apply two controlled transformations. Ordered retention randomly retains 20–100% of observations while preserving their relative order, modeling increasingly sparse sampling. Partial permutation selects 0–100% of positions and randomly permutes only their values. The latter preserves the complete marginal value multiset and changes only temporal order. Interior points use three seeds; endpoints use one. All VIREL outputs are raw-word exact; Falcon, ELF*, ALP, and DeXOR are included as ratio baselines, and raw-word differences are not used to rank throughput. Figure 8 shows that at 20% retention, V IREL-Exact-Upper reaches 6.24× versus 4.82× for Falcon and 3.94× for DeXOR, while V IREL-Exact-Fast reaches 5.43×. Under full partial permutation, the upper profile remains at 3.98× versus 3.40× for the strongest external baseline (ALP); the fast profile is 3.69×. Temporal order drives a substantial part of the gain, but exact multi-scale routing remains useful after order is destroyed.
VIREL-Exact-Fast VIREL-Exact-Upper
Falcon ELF*
ALP DeXOR
VIREL-Exact-Fast VIREL-Exact-Upper
Falcon ELF*
ALP DeXOR
ordered retention isolated
7
compression ratio
compression ratio
12 10 8 6
6 5 4 3
4
20 0
0.1
1
10
40
high-precision exceptions (%) burst
60
80
100
percentage (%) partial permutation
100
7
12
6
10
5
8
4
6
3
4
0 0
0.1
1
10
100
20
40
60
80
100
percentage (%)
high-precision exceptions (%) Fig. 7. Batch: Controlled mixed-precision compression. Route-persistent lanes keep each precision stream predictable under interleaving and bursty exceptions. Falcon is included for ratio only; its GPU throughput is not ranked against CPU codecs.
Fig. 8. Batch: Whole-column robustness under ordered retention and partial permutation. VIREL-Fast and VIREL-Upper keep higher ratios than Falcon, ELF*, ALP, and DeXOR as sampling becomes sparse; destroying temporal order narrows, but does not remove, the advantage.
E. Parallelism and Storage Integration
TABLE XI I NDEPENDENT STRUCTURE SWEEPS FOR THE CURRENT V IREL -E XACT-FAST CORE STREAM , BEFORE PAGE - GROUP METADATA FACTORING AND SECONDARY COMPRESSION .
Axis and value
Ratio Comp. MB/s Decomp. MB/s
Frame 100 Frame 512 Frame 1000 Frame 1024 Frame 2000 Frame 4000
4.9653 5.7154 5.8083 5.8148 5.8484 5.8454
39.43 39.84 38.93 40.05 37.78 34.93
309.11 665.38 789.06 774.51 850.41 886.51
Residual 4 Residual 8 Residual 16 Residual 32 Residual 64 Residual 128
5.5529 5.7482 5.8148 5.8282 5.8217 5.8090
45.08 41.49 39.90 61.19 63.35 64.83
765.02 813.55 778.67 765.45 741.12 721.99
e) Frame and residual-block sensitivity.: Table XI sweeps frame and residual-block sizes independently. F = 2,000 is the best frame size in this core-only sweep, with F = 1,024 within 0.58% in ratio while matching the production page boundary. Residual blocks of 32 values give the highest core ratio; the reported profiles keep B = 16 as the fixed production format used by the page-container experiments.
a) Equal-core scaling.: The scaling corpus contains 72,947 independent frames (569.9 MiB). All methods use the same persistent C++ pool pinned to 1/2/4/8/16/32 physical cores. Pool construction, loading, and verification are excluded; allocation is included. Nested library threading is disabled. Each method emits identical bytes at every core count. V IREL-Exact-Fast’s core stream reaches 97.8% encode and 94.9% decode parallel efficiency at 32 cores, yielding 1,575/17,643 MB/s. The core stream ratio is 7.4544×; the page-group secondary container used in the large ratio experiment raises the single-thread size result to 8.0629×. b) TsFile: Page path.: We register V IREL-Exact-Fast, ELF*, and the official DeXOR artifact wrapper as DOUBLE encodings in Apache TsFile C++ 2.2-dev. The VIREL path uses the FastFWC page codec, matching the deploymentoriented exact profile rather than the compression-first Upper profile. PageWriter supplies exactly 1,024 values; timestamps, headers, statistics, indexes, and optional LZ4 remain native. We write Household ActivePower, Beijing TEMP, GeoLife latitude, and T-Drive longitude, then measure full scan, middle10% range scan, and reader-side count/min/max/sum. Ratio charges the complete file. Table XII reports medians of three writes and warm queries. V IREL-Exact-Fast uses 27.07% fewer complete-file bytes
VIREL-Fast core ELF*
coding, metadata, and file I/O; scan throughput includes the complete reader and lane scatter. These boundaries differ from the in-memory microbenchmark.
DeXOR Gorilla
MB/s
encode 10
4
10
3
10
2
VIII. R ELATED W ORK
decode
4
10
3
MB/s
10
1
2
4
8
16
32
cores Fig. 9. Uniform persistent-pool scaling on the 48-stream, 1,024-value corpus. VIREL uses the FastFWC core stream without page-group secondary compression; ALP is omitted and DeXOR is descriptive because it is not raw-word exact on this corpus. Axes are logarithmic. TABLE XII T S F ILE : E ND - TO - END RESULTS OVER 6.62 MILLION VALUES .
Value codec
Secondary
V IREL-Exact-Fast none V IREL-Exact-Fast LZ4 ELF* none ELF* LZ4 DeXOR† none DeXOR† LZ4 Gorilla none Gorilla LZ4 Plain none Plain LZ4
Ratio Write
Full Range Aggr.
6.0630 15.44 99.51 6.7847 15.39 99.72 4.4092 55.65 95.29 4.7218 55.87 95.89 4.4218 40.00 88.11 4.7332 39.66 87.76 1.3836 52.29 72.77 1.5038 52.21 70.91 0.9697 64.85 106.83 1.5398 70.26 102.23
93.56 101.21 95.23 102.91 89.63 99.80 90.97 99.73 83.36 91.51 84.13 90.97 64.63 75.45 64.76 73.54 89.01 111.76 87.21 103.52
than DeXOR without LZ4, 30.24% fewer than DeXOR with LZ4, 27.28% fewer than ELF* without LZ4, and 30.41% fewer than ELF* with LZ4. DeXOR and ELF* write faster; V IREL-Exact-Fast is competitive or faster on the three read paths. VIREL, ELF*, Gorilla, and Plain reproduce every IEEE word. The marked official DeXOR artifact differs on 2,057,382 of 6,622,208 words under our bitwise checker and remains descriptive. Write throughput includes page assembly, timestamp en-
a) Database and time-series compression.: Database systems have long exploited compressed column execution and block-level encoding choices [13], [14]. Time-series systems add ordered ingestion, page/chunk boundaries, and query-time scans [16], [17]. Gorilla showed that an operational TSDB can make floating-point XOR coding part of the storage path [1]; Apache IoTDB exposes pluggable TsFile encodings and scaled-integer/difference options [10], [11]. VIREL follows this systems boundary: it is a page codec with bounded memory, exact fallback, and a TsFile integration. The algorithmic difference is that scale is not a schema-level policy. VIREL discovers page-local numerical representations, validates them against the active contract, and preserves separate prediction states for interleaved source resolutions. b) IEEE-word prediction and erasure.: FPC predicts binary64 words with finite-context and differential predictors, then compresses XOR residuals [18]. FPZIP predicts floatingpoint arrays and encodes residuals in lossless or precisioncontrolled form [19]. Gorilla encodes meaningful intervals of adjacent IEEE-word XORs [1]; Chimp improves leadingzero coding and window reuse [2]. ELF identifies a decimal significand and erases a mantissa suffix that can be restored during decoding, while ELF+, SElfStar, and ELF* refine beta coding, zero pruning, window sharing, and entropy codes [3], [4]. These designs are robust because they stay close to the IEEE word. Their cost is that binary conversion tails remain inside the temporal residual. VIREL uses the wordlevel path only for exceptions; its primary predictor sees validated numerical integers. c) Decimal-space exact codecs.: ALP learns decimal exponent/factor pairs, packs the resulting integers, and stores nonrepresentable values as exceptions [5]. Camel separates decimal integer and fractional structure across neighboring values [6]. DeXOR realigns adjacent values in decimal space, encodes common prefixes and scaled suffixes, and handles exponent or precision anomalies separately [7]. These works establish that decimal structure is a central source of lossless floating-point compressibility. VIREL uses that same insight at a different state boundary. Instead of treating the integer as a vector payload or the decimal representation as an adjacentpair object, VIREL makes admitted integers the time-series prediction state. Selected scales form routed subsequences, and route-local histories survive intervening values of other scales. The compression-first profile also searches affine sublattices q = dz + r and stores z, removing physical step sizes that remain after decimal alignment. The mixed-precision experiments isolate this state boundary from mere decimal conversion. d) Float-to-integer transforms.: Several systems convert floating-point values to integer surrogates before integer coding. Ant uses an integer form, adjacent deltas, ZigZag coding,
and leading-zero suppression for IoT streams [8]. Falcon computes decimal places with guarantees, converts recoverable values to integer significands at a chunk-wide scale, falls back to IEEE-bit integers, applies adjacent deltas, and uses GPU-friendly sparse bit planes [9]. These systems show that “float-to-integer plus delta” is an important primitive rather than a VIREL invention. VIREL’s contribution is the contractchecked, route-local, and lattice-normalized version of that primitive. Decimal alignment gives an integer coordinate; VIREL may then identify the physical sub-lattice of that coordinate and encode z for q = dz + r. Several such integer processes may coexist in one page, predictor state is keyed by route, and the error-bounded profile can factor a fine lattice into coarser exact divisor lanes without spending error budget. We therefore report Falcon as a ratio baseline but do not mix its GPU throughput with CPU throughput rankings. e) Integer residual backends.: Once values are integers, delta, delta-of-delta, frame-of-reference, bit packing, Rice codes, and sparse patches are standard tools. Sprintz combines forecasting, bit packing, and SIMD execution for multivariate integer time series [20]; BtrBlocks chooses among column encodings with a cost model [14]. VIREL’s backend deliberately uses this conservative toolkit. The novelty is not a new universal entropy code; it is where the integer residual stream comes from and how mixed source resolutions are kept predictable before those standard integer encoders are applied. f) Learned and model-based compression.: LeCo learns serial correlations and stores residuals for random-access column reconstruction [21]. MOST combines model-based prediction with outlier storage for time-series data [22]. NeaTS fits nonlinear functions to segments and stores corrections for lossless or error-bounded random access [23]. These methods enlarge the predictor family and optimize access granularity. VIREL instead keeps predictors simple and changes the floating-point representation boundary: it validates numerical admission, routes interleaved resolutions, and shares one integer residual backend across exact and error-bounded contracts. g) Error-bounded compression.: Classical streaming schemes such as RACE and LFZip trade bounded error for smaller time-series payloads through adaptive or predictive quantization [24], [25]. Serf targets scalar streams; Serf-Qt quantizes temporal changes, while Serf-XOR searches the admissible interval for a compact floating-point representation [15]. Decomposed bounded floats separate queryable bounded components [26]. Scientific compressors such as SZ, ZFP, and MGARD target multidimensional arrays, progressive reconstruction, or norm-based contracts [27], [28], [29]. VIREL-EB is narrower: ordered scalar pages under a pointwise absolute bound. Its difference from prior scalar EB codecs is exact source-resolution factoring: after validating a lattice index q, VIREL may encode q/d only when divisibility holds and decodes the same q before reconstruction. The factor operation changes residual magnitude, not the checked error.
IX. C ONCLUSION VIREL’s central observation is that ALP-style decimal integerization exposes an ordered integer-lattice residual signal that word-level XOR and block packing do not fully use. VIREL validates the integer map under the active fidelity contract, then predicts route-local decimal/lattice integers and encodes their residuals. Resolution routes preserve independent histories when precision interleaves; costed lattice-step normalization maps sparse coordinates q = dz + r to compact lane coordinates z in the compression-first exact profile; sparse width patches encode residual outliers, and exact raw fallback closes both contracts. In error-bounded mode, exact divisor factoring of validated lattice indices and multi-lane routing recover source resolution without consuming error. The mechanism is supported by both scale and ablation evidence. Removing integer-domain residual prediction increases exact output by 59.28%; collapsing to one scale lane adds 7.45%, and resetting route state adds 4.11%. On the canonical 14 streams, V IREL-Exact-Upper emits 22.4% fewer bytes than Falcon’s GPU bit-plane pipeline; Falcon is treated as a ratio baseline rather than a CPU throughput competitor. On 74.70 million values, V IREL-Exact-Upper emits 48.34% fewer bytes than ELF* and 27.48% fewer than Falcon. At ϵ = 10−3 , the reporting VIREL-EB profile emits 12.54% fewer bits than Machete, the strongest of five compliant external baselines, while preserving 12.1094× and reaching 164.56 MB/s encode throughput on 16 threads. Its multi-resolution gain rises from 1.47% to 36.86% as the requested lattice tightens. The exact path scales to 32 cores and runs inside TsFile’s native page lifecycle. These results identify validated decimal/lattice residual prediction as the primary compression primitive; latticestep normalization plus multi-resolution lanes preserve that primitive under heterogeneous precision and error bounds. R EFERENCES [1] T. Pelkonen, S. Franklin, J. Teller, P. Cavallaro, Q. Huang, J. Meza, and K. Veeraraghavan, “Gorilla: A fast, scalable, in-memory time series database,” Proceedings of the VLDB Endowment, vol. 8, no. 12, pp. 1816–1827, 2015. [2] P. Liakos, K. Papakonstantinopoulou, and S. Sioutas, “Chimp: Efficient lossless floating point compression for time series databases,” Proceedings of the VLDB Endowment, vol. 15, no. 11, pp. 3058–3070, 2022. [3] Y. Li, Y. Zhang, G. Li, and X. S. Wang, “Elf: Erasing-based lossless floating-point compression,” Proceedings of the VLDB Endowment, vol. 16, no. 7, pp. 1763–1776, 2023. [4] R. Li, Z. Li, Y. Wu, C. Chen, T. Liu, and Y. Zheng, “Adaptive encoding strategies for lossless floating-point compression,” IEEE Internet of Things Journal, 2025. [5] A. Afroozeh, L. X. Kuffo, and P. Boncz, “Alp: Adaptive lossless floatingpoint compression,” Proceedings of the ACM on Management of Data, vol. 1, no. 4, pp. 1–26, 2023. [6] Y. Yao, L. Chen, Z. Fang, Y. Gao, C. S. Jensen, and T. Li, “Camel: Efficient compression of floating-point time series,” Proceedings of the ACM on Management of Data, vol. 2, no. 6, pp. 1–26, 2024. [7] C. Lv, H. Li, D. Yang, Z. Xie, L. Chen, and C. S. Jensen, “Dexor: Enabling xor in decimal space for streaming lossless compression of floating-point data,” Proceedings of the VLDB Endowment, vol. 19, no. 5, pp. 849–861, 2026. [8] J. Li, G. Xu, H. Yang, and Y. Wu, “Ant: An efficient lossless compression algorithm for iot time series data,” in 2023 IEEE Intl Conf on Parallel & Distributed Processing with Applications, Big Data & Cloud Computing, Sustainable Computing & Communications, Social Computing & Networking, 2023, pp. 766–771.
[9] Z. Li, W. Wang, R. Li, C. Chen, X. Long, L. Zheng, Q. Xu, and C. Yang, “A high-throughput gpu framework for adaptive lossless compression of floating-point data,” arXiv preprint arXiv:2511.04140, 2025. [10] J. Wang et al., “Apache iotdb: Time-series database for internet of things,” Proceedings of the VLDB Endowment, vol. 13, no. 12, pp. 2901– 2904, 2020. [11] T. Xia, J. Xiao, Y. Huang, C. Hu, S. Song, X. Huang, and J. Wang, “Time series data encoding in apache iotdb: Comparative analysis and recommendation,” The VLDB Journal, vol. 33, no. 3, pp. 727–752, 2024. [12] “Ieee standard for floating-point arithmetic,” IEEE Std 754-2019, pp. 1–84, 2019. [13] D. J. Abadi, S. R. Madden, and M. C. Ferreira, “Integrating compression and execution in column-oriented database systems,” in Proceedings of the ACM SIGMOD International Conference on Management of Data, 2006, pp. 671–682. [14] M. Kuschewski, D. Sauerwein, A. Alhomssi, and V. Leis, “Btrblocks: Efficient columnar compression for data lakes,” Proceedings of the ACM on Management of Data, vol. 1, no. 2, pp. 1–26, 2023. [15] R. Li, Z. Chen, R. Lu, X. Xu, G. Yang, C. Chen, J. Bao, and Y. Zheng, “Serf: Streaming error-bounded floating-point compression,” Proceedings of the ACM on Management of Data, vol. 3, no. 3, 2025. [16] S. K. Jensen, T. B. Pedersen, and C. Thomsen, “Time series management systems: A survey,” IEEE Transactions on Knowledge and Data Engineering, vol. 29, no. 11, pp. 2581–2600, 2017. [17] G. Chiarot and C. Silvestri, “Time series compression: A survey,” ACM Computing Surveys, vol. 55, no. 10, pp. 1–32, 2023. [18] M. Burtscher and P. Ratanaworabhan, “High throughput compression of double-precision floating-point data,” in Data Compression Conference, 2009, pp. 293–302. [19] P. Lindstrom and M. Isenburg, “Fast and efficient compression of floating-point data,” IEEE Transactions on Visualization and Computer Graphics, vol. 12, no. 5, pp. 1245–1250, 2006. [20] D. Blalock, S. Madden, and J. Guttag, “Sprintz: Time series compression for the internet of things,” Proceedings of the ACM on Interactive, Mobile, Wearable and Ubiquitous Technologies, vol. 2, no. 3, pp. 1– 23, 2018. [21] Y. Liu, X. Zeng, and H. Zhang, “Leco: Lightweight compression via learning serial correlations,” Proceedings of the ACM on Management of Data, vol. 2, no. 1, 2024. [22] Z. Yang and S. Chen, “Most: Model-based compression with outlier storage for time series data,” Proceedings of the ACM on Management of Data, vol. 1, no. 4, 2023. [23] A. Guerra, G. Vinciguerra, A. Boffa, and P. Ferragina, “Learned compression of nonlinear time series with random access,” in 2025 IEEE 41st International Conference on Data Engineering, 2025, pp. 1579– 1592. [24] H. Chen, J. Li, and P. Mohapatra, “Race: Time series compression with rate adaptivity and error bound for sensor networks,” in IEEE International Conference on Mobile Ad-hoc and Sensor Systems, 2004, pp. 124–133. [25] S. Chandak, K. Tatwawadi, C. Wen, L. Wang, J. Aparicio Ojea, and T. Weissman, “Lfzip: Lossy compression of multivariate floatingpoint time series data via improved prediction,” in Data Compression Conference, 2020, pp. 342–351. [26] C. Liu, H. Jiang, J. Paparrizos, and A. J. Elmore, “Decomposed bounded floats for fast compression and queries,” Proceedings of the VLDB Endowment, vol. 14, no. 11, pp. 2586–2598, 2021. [27] S. Di and F. Cappello, “Fast error-bounded lossy hpc data compression with sz,” in 2016 IEEE International Parallel and Distributed Processing Symposium, 2016, pp. 730–739. [28] P. Lindstrom, “Fixed-rate compressed floating-point arrays,” IEEE Transactions on Visualization and Computer Graphics, vol. 20, no. 12, pp. 2674–2683, 2014. [29] M. Ainsworth, S. Klasky, and B. Whitney, “Multilevel techniques for compression and reduction of scientific data—the univariate case,” Computing and Visualization in Science, vol. 19, pp. 65–76, 2018.