ndwt

N-Dimensional Wavelet transforms for real and complex signals in Rust.

Provides two transform families:

• DWT — the classic Discrete Wavelet Transform via convolution and subsampling.
• LWT — the Lifting Wavelet Transform, an in-place factorisation of the DWT that is length-preserving and cache-friendly.

Both families support 1-D and N-D transforms on arbitrary axes, multi-level decomposition, SIMD acceleration via pulp, optional Rayon parallelism, and real or complex element types. Adjoint (transpose) operations are provided for every forward and inverse transform, respecting the chosen boundary extension, which makes the transforms suitable for use in optimization and inverse problems.

Installation

[dependencies]

ndwt = "0.1"

Default features enable rayon (multi-threading), ndarray integration, and x86-v3 (AVX2/FMA) SIMD paths. See Feature flags for details.

Quick start

DWT — 1-D signal

use ndwt::Wavelets;
use ndwt::boundarys::ZeroBoundary;
use ndwt::dwt::driver::{WaveletTransform, get_transform_shape};

let wvlt = Wavelets::Daubechies4;
let level = 3;
let shape = [128_usize];
let axes = [0_usize];

let trans = WaveletTransform::new(wvlt, ZeroBoundary);

let x: Vec<f64> = (0..128).map(|i| i as f64 / 127.0).collect();

// Output is larger than input because non-periodic DWT pads at each level.
let out_shape = get_transform_shape(&shape, &axes, level, wvlt.width(), false);
let mut coeffs = vec![0.0_f64; out_shape.iter().product()];
trans.forward_multilevel_nd(&x, &mut coeffs, &shape, &axes, level);

// Reconstruct.
let mut x2 = vec![0.0_f64; 128];
trans.inverse_multilevel_nd(&mut coeffs, &mut x2, &shape, &axes, level);

LWT — 2-D image (periodic boundary)

use ndwt::Wavelets;
use ndwt::boundarys::BoundaryCondition;
use ndwt::lwt::driver::WaveletTransform;

let wvlt = Wavelets::Daubechies4;
let level = 3;
let shape = [64_usize, 64];
let axes = [0_usize, 1]; // both axes

let trans = WaveletTransform::new(wvlt, BoundaryCondition::Periodic);

let x: Vec<f64> = (0..64 * 64).map(|i| ((i as f64) * 0.17).sin()).collect();

// LWT is length-preserving: output has the same shape as input.
let mut coeffs = vec![0.0_f64; 64 * 64];
trans.forward_multilevel_nd(&x, &mut coeffs, &shape, &axes, level);

let mut x2 = vec![0.0_f64; 64 * 64];
trans.inverse_multilevel_nd(&coeffs, &mut x2, &shape, &axes, level);

Supported wavelets

Each wavelet type is a zero-size marker struct carrying filter coefficients as compile-time constants. The Wavelets enum lets you select a wavelet at runtime without generics.

Boundary conditions

Compile-time boundary types (ZeroBoundary, PeriodicBoundary) are also available for zero-cost dispatch. The BoundaryCondition enum enables runtime selection.

Feature flags

Disable default features to get a minimal build with no SIMD or parallelism:

ndwt = { version = "0.1", default-features = false }

License

MIT — see LICENSE.md.