FZGPUModules/fzgpumodules_8h_source.html

#pragma once


#include <vector>


#include "backend/types.h"

#include "fzm_format.h"


#include "pipeline/compressor.h"

#include "pipeline/stat.h"


// CompressionDAG and the fusion planner/registry are the ADVANCED tier — no

// source-compatibility promise. Pipeline still works without naming them (they are

// pulled transitively by compressor.h), so this umbrella no longer advertises them.

// Reach for them deliberately: #include "advanced/dag.h", "advanced/fusion_*.h".


#include "stage/stage.h"


#include "log.h"


#include "predictors/diff/diff.h"

#include "predictors/lorenzo/lorenzo_stage.h"

#include "predictors/tiled_lorenzo/tiled_lorenzo_stage.h"

#include "coders/rle/rle.h"

#include "coders/bitpack/bitpack_stage.h"

#include "coders/adaptive_bitpack/adaptive_bitpack_stage.h"

#include "coders/rze/rze_stage.h"

#include "coders/rre/rre_stage.h"

#include "coders/rare/rare_stage.h"

#include "coders/raze/raze_stage.h"

#include "coders/clog/clog_stage.h"

#include "coders/hclog/hclog_stage.h"

#include "coders/gpulz/gpulz_stage.h"

#include "coders/speck2d/speck2d_stage.h"

#include "coders/cdf97_outlier_correct/cdf97_outlier_correct_stage.h"

#include "shufflers/tupl/tupl_stage.h"

#include "structural/merge/merge_stage.h"

#include "fused/adaptive_lorenzo/adaptive_lorenzo_stage.h"

#include "fused/lorenzo_quant/lorenzo_quant.h"

#include "quantizers/quantizer/quantizer.h"

#include "transforms/zigzag/zigzag_stage.h"

#include "transforms/log_transform/log_transform_stage.h"

#include "transforms/cdf97/cdf97_stage.h"

#include "transforms/negabinary/negabinary.h"

#include "transforms/negabinary/negabinary_stage.h"

#include "shufflers/bitshuffle/bitshuffle_stage.h"

#include "coders/huffman/huffman_stage.h"

#include "coders/ans/ans_stage.h"

#include "transforms/adm/adm_stage.h"

#include "fused/ginterp/ginterp_stage.h"

#include "fused/bitplane_rze/bitplane_rze_stage.h"

#include "structural/roibin_split/roibin_split_stage.h"

#include "fused/szx/szx_stage.h"

#include "fused/szp/szp_stage.h"

adaptive_bitpack_stage.h
Per-block adaptive fixed-rate bit-plane coder (cuSZp-style plain mode).

adaptive_lorenzo_stage.h
Per-tile adaptive multi-order Lorenzo predictor with centering. Lossless.

adm_stage.h
Adaptive Data Mapping (ADM) stage — remaps u16/u32 integer streams into a compact 8-bit symbol domain...

ans_stage.h
rANS entropy coding stage (GPU, via vendored dietGPU kernel templates).

bitpack_stage.h
Bit-packing stage: packs N-bit integers into a dense byte stream.

bitplane_rze_stage.h
Fused bitplane-transpose + zero-group RZE stage — the FZ-GPU lossless encoder, ported as a single-ker...

bitshuffle_stage.h
GPU bit-matrix transpose stage (W × N bit shuffle over fixed-size chunks).

cdf97_outlier_correct_stage.h
Cdf97OutlierCorrectStage — the CDF 9/7 instantiation of the generic OutlierCorrectStage<Reconstructor...

cdf97_stage.h
CDF 9/7 biorthogonal wavelet transform stage (SPERR's DWT front-half).

clog_stage.h
LC CLOG leading-zero compression and adaptive bit-packing stage.

compressor.h
Pipeline builder and execution API.

diff.h
First-order difference coding stage with optional negabinary fusion.

fzm_format.h
FZM binary file format definitions — structs, enums, and helpers.

ginterp_stage.h
G-Interp spline-interpolation predictor + quantizer (cuSZ-Hi port).

gpulz_stage.h
GPULZ stage — GPU LZSS (LZ77 + flag-bit literal/match coding) lossless byte-stream compressor.

hclog_stage.h
LC HCLOG leading-zero compression with per-subchunk TCMS selection.

huffman_stage.h
Huffman entropy coding stage.

log.h
Logging infrastructure and macros.

log_transform_stage.h
Log-space transform for point-wise relative error bounds.

lorenzo_quant.h
Fused Lorenzo predictor and quantizer stage.

lorenzo_stage.h
Plain integer Lorenzo predictor (delta coding / prefix sum). Lossless.

merge_stage.h
MergeStage — concatenate N input buffers into one, split back to N.

negabinary.h
Negabinary (base -2) integer encoding helpers.

negabinary_stage.h
Element-wise negabinary encode/decode stage (TIn[] ↔ TOut[]).

quantizer.h
Direct-value quantizer stage with error-bounded coding and lossless outlier fallback.

rare_stage.h
LC RARE adaptive top-bit matching reducer — lossless byte-stream compressor.

raze_stage.h
LC RAZE adaptive leading-zero-bit reducer — lossless byte-stream compressor.

rle.h
Run-Length Encoding stage (lossless, stream-ordered).

roibin_split_stage.h
ROIBinSplitStage — split a detector field into a full-resolution region-of-interest stream and a (opt...

rre_stage.h
LC RRE repeated-word bitmap reducer — lossless byte-stream compressor.

rze_stage.h
LC RZE zero-word bitmap reducer — lossless byte-stream compressor.

speck2d_stage.h
GPU-parallel "wavefront" SPECK-like coder (2-D), see speck2d_kernels.cuh for the algorithm/format and...

stage.h
Base class interface for all compression stages.

stat.h
Reconstruction quality metrics (MSE, PSNR, max error, NRMSE).

szp_stage.h
SZp (a.k.a. fZ-light) — extreme-fast error-bounded compressor, as a fused stage.

szx_stage.h
SZx — ultrafast error-bounded lossy compressor, as a fused stage.

tiled_lorenzo_stage.h
Dimension-aware (tiled separable) Lorenzo predictor — cuSZp3 delta. Lossless.

tupl_stage.h
GPU tuple deinterleave stage (AoS -> SoA transpose over fixed-size blocks).

types.h
Backend-neutral GPU type aliases.

zigzag_stage.h
Element-wise zigzag encode/decode stage (TIn[] ↔ TOut[]).