FZGPUModules/fzgpumodules_8h_source.html

#pragma once


#include <vector>


#include "backend/types.h"

#include "fzm_format.h"


#include "pipeline/compressor.h"

#include "pipeline/dag.h"

#include "pipeline/stat.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 "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/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"

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).

clog_stage.h
Compressed-Logarithm (adaptive bit-width) coding stage — lossless byte-stream compressor.

compressor.h
Pipeline builder and execution API.

dag.h
Compression DAG wiring, execution, and memory strategy types.

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
Compressed-Logarithm coding with a per-subchunk TCMS fallback — lossless byte-stream compressor.

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
Repetition-Adaptive Reduction Encoding stage — lossless byte-stream compressor.

raze_stage.h
Zero-Adaptive Reduction Encoding stage — lossless byte-stream compressor.

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

rre_stage.h
Repetition-Reduction Encoding stage — lossless byte-stream compressor.

rze_stage.h
Zero-Elimination Encoding stage — lossless byte-stream compressor.

stage.h
Base class interface for all compression stages.

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

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[]).