Struct FpZipCompressor 

pub struct FpZipCompressor { /* private fields */ }

Builder for configuring and executing fpzip compression.

Provides a fluent API for setting dimensions and precision before compressing. Defaults to 1D (ny=1, nz=1, nf=1) at full precision (lossless).

Example

use fpzip_rs::{FpZipCompressor, decompress_f32};

let data: Vec<f32> = (0..64).map(|i| i as f32).collect();
let compressed = FpZipCompressor::new(4)
    .ny(4)
    .nz(4)
    .compress_f32(&data)
    .unwrap();

let decompressed = decompress_f32(&compressed).unwrap();
assert_eq!(data, decompressed);

Implementations

impl FpZipCompressor

pub fn new(nx: u32) -> Self

Creates a new compressor for an array with X dimension nx.

pub fn ny(self, ny: u32) -> Self

Sets the Y dimension (default: 1).

pub fn nz(self, nz: u32) -> Self

Sets the Z dimension (default: 1).

pub fn nf(self, nf: u32) -> Self

Sets the number of fields / 4th dimension (default: 1).

pub fn prec(self, prec: u32) -> Self

Sets the bit precision for lossy compression.

• 0 or full type width (32 for float, 64 for double) = lossless.
• For float: valid range is 2..=32.
• For double: valid range is 4..=64 (even values only).
• Lower precision gives better compression ratios at the cost of accuracy.

pub fn compress_f32(&self, data: &[f32]) -> Result<Vec<u8>>

Compresses a float slice with the configured dimensions and precision.

pub fn compress_f64(&self, data: &[f64]) -> Result<Vec<u8>>

Compresses a double slice with the configured dimensions and precision.

pub fn compress_f32_into(&self, data: &[f32], dest: &mut [u8]) -> Result<usize>

Compresses a float slice into a pre-allocated buffer.

pub fn compress_f64_into(&self, data: &[f64], dest: &mut [u8]) -> Result<usize>

Compresses a double slice into a pre-allocated buffer.