Crate oxifft 

OxiFFT

Pure Rust implementation of FFTW - the Fastest Fourier Transform in the West.

OxiFFT provides high-performance FFT routines with:

• Complex DFT (forward and inverse)
• Real FFT (R2C/C2R)
• DCT/DST transforms
• Multi-dimensional transforms
• Batch processing
• SIMD optimization
• Threading support
• Wisdom system for plan caching

Quick Start

use oxifft::{Complex, Direction, Flags, Plan};

// Create a plan for a 256-point forward FFT.
let plan = Plan::dft_1d(256, Direction::Forward, Flags::MEASURE)
    .expect("256 is a supported transform size");

// Execute the transform.
let input = vec![Complex::new(1.0, 0.0); 256];
let mut output = vec![Complex::zero(); 256];
plan.execute(&input, &mut output);

Re-exports

pub use api::fft;

pub use api::fft2d;

pub use api::fft2d_split;

pub use api::fft3d_split;

pub use api::fft_batch;

pub use api::fft_nd;

pub use api::fft_nd_split;

pub use api::fft_split;

pub use api::ifft;

pub use api::ifft2d;

pub use api::ifft2d_split;

pub use api::ifft3d_split;

pub use api::ifft_batch;

pub use api::ifft_nd;

pub use api::ifft_nd_split;

pub use api::ifft_split;

pub use api::irfft;

pub use api::irfft2d;

pub use api::irfft3d;

pub use api::irfft_batch;

pub use api::irfft_nd;

pub use api::rfft;

pub use api::rfft2d;

pub use api::rfft3d;

pub use api::rfft_batch;

pub use api::rfft_nd;

pub use api::Direction;

pub use api::Flags;

pub use api::GuruPlan;

pub use api::InvalidDirection;

pub use api::Plan;

pub use api::Plan2D;

pub use api::Plan3D;

pub use api::PlanND;

pub use api::R2rPlan;

pub use api::R2rPlan2D;

pub use api::R2rPlan3D;

pub use api::RealPlan;

pub use api::RealPlan2D;

pub use api::RealPlan3D;

pub use api::RealPlanKind;

pub use api::RealPlanND;

pub use api::SplitPlan;

pub use api::SplitPlan2D;

pub use api::SplitPlan3D;

pub use api::SplitPlanND;

pub use kernel::Complex;

pub use kernel::Float;

pub use kernel::IoDim;

pub use kernel::Tensor;

pub use kernel::F128;

pub use kernel::F16;

pub use sparse::sparse_fft;

pub use sparse::sparse_ifft;

pub use sparse::SparsePlan;

pub use sparse::SparseResult;

pub use pruned::fft_pruned_input;

pub use pruned::fft_pruned_output;

pub use pruned::fft_pruned_output_butterfly;

pub use pruned::goertzel;

pub use pruned::goertzel_multi;

pub use pruned::PrunedPlan;

pub use pruned::PruningMode;

pub use wasm::fft_f32;

pub use wasm::fft_f64;

pub use wasm::ifft_f32;

pub use wasm::ifft_f64;

pub use wasm::rfft_f64;

pub use wasm::WasmFft;

pub use wasm::WasmSimdF32;

pub use wasm::WasmSimdF64;

pub use streaming::blackman;

pub use streaming::build_mel_filterbank;

pub use streaming::cola_normalization;

pub use streaming::hamming;

pub use streaming::hann;

pub use streaming::istft;

pub use streaming::istft_overlap_save;

pub use streaming::kaiser;

pub use streaming::magnitude_spectrogram;

pub use streaming::mel_spectrogram;

pub use streaming::mfcc;

pub use streaming::phase_spectrogram;

pub use streaming::power_spectrogram;

pub use streaming::rectangular;

pub use streaming::single_bin_tracker;

pub use streaming::sliding_dft;

pub use streaming::stft;

pub use streaming::stft_overlap_save;

pub use streaming::MelConfig;

pub use streaming::ModulatedSdft;

pub use streaming::RingBuffer;

pub use streaming::SingleBinTracker;

pub use streaming::SlidingDft;

pub use streaming::StreamingFft;

pub use streaming::WindowFunction;

pub use const_fft::const_cos;

pub use const_fft::const_sin;

pub use const_fft::fft_fixed;

pub use const_fft::fft_fixed_inplace;

pub use const_fft::ifft_fixed;

pub use const_fft::ifft_fixed_inplace;

pub use const_fft::twiddle_factor;

pub use const_fft::ConstFft;

pub use const_fft::ConstFftImpl;

pub use dft::solvers::ct::fft_radix2;

pub use dft::solvers::ct::fft_radix2_inplace;

pub use dft::solvers::ct::ifft_radix2;

pub use dft::solvers::ct::ifft_radix2_inplace;

pub use dft::solvers::ct::ifft_radix2_normalized;

pub use dft::solvers::direct::dft_direct;

pub use dft::solvers::direct::idft_direct;

pub use dft::solvers::direct::idft_direct_normalized;

pub use dft::solvers::nop::dft_nop;

pub use rdft::solvers::dct1;

pub use rdft::solvers::dct2;

pub use rdft::solvers::dct3;

pub use rdft::solvers::dct4;

pub use rdft::solvers::dht;

pub use rdft::solvers::dst1;

pub use rdft::solvers::dst2;

pub use rdft::solvers::dst3;

pub use rdft::solvers::dst4;

pub use rdft::solvers::R2rKind;

pub use api::alloc_complex;

pub use api::alloc_complex_aligned;

pub use api::alloc_real;

pub use api::alloc_real_aligned;

pub use api::is_aligned;

pub use api::AlignedBuffer;

pub use api::DEFAULT_ALIGNMENT;

pub use nufft::nufft2d_type1;

pub use nufft::nufft2d_type2;

pub use nufft::nufft3d_type1;

pub use nufft::nufft_type1;

pub use nufft::nufft_type2;

pub use nufft::nufft_type3;

pub use nufft::Nufft;

pub use nufft::NufftError;

pub use nufft::NufftOptions;

pub use nufft::NufftResult;

pub use nufft::NufftType;

pub use frft::frft;

pub use frft::frft_checked;

pub use frft::ifrft;

pub use frft::ifrft_checked;

pub use frft::Frft;

pub use frft::FrftError;

pub use frft::FrftResult;

pub use conv::convolve;

pub use conv::convolve_circular;

pub use conv::convolve_complex;

pub use conv::convolve_complex_mode;

pub use conv::convolve_mode;

pub use conv::convolve_with_mode;

pub use conv::correlate;

pub use conv::correlate_complex;

pub use conv::correlate_complex_mode;

pub use conv::correlate_mode;

pub use conv::polynomial_multiply;

pub use conv::polynomial_multiply_complex;

pub use conv::polynomial_power;

pub use conv::ConvMode;

pub use ntt::intt;

pub use ntt::ntt;

pub use ntt::ntt_convolve;

pub use ntt::ntt_convolve_default;

pub use ntt::NttError;

pub use ntt::NttPlan;

pub use ntt::NTT_PRIME_998244353;

pub use ntt::NTT_PRIME_MOD1;

pub use ntt::NTT_PRIME_MOD2;

pub use autodiff::fft_dual;

pub use autodiff::fft_jacobian;

pub use autodiff::grad_fft;

pub use autodiff::grad_ifft;

pub use autodiff::jvp_fft;

pub use autodiff::vjp_fft;

pub use autodiff::DiffFftPlan;

pub use autodiff::Dual;

pub use autodiff::DualComplex;

pub use chirp_z::CztError;

pub use chirp_z::CztPlan;

pub use chirp_z::CztResult;

pub use signal::coherence;

pub use signal::complex_cepstrum;

pub use signal::cross_spectral_density;

pub use signal::envelope;

pub use signal::hilbert;

pub use signal::instantaneous_frequency;

pub use signal::instantaneous_phase;

pub use signal::minimum_phase;

pub use signal::periodogram;

pub use signal::real_cepstrum;

pub use signal::resample;

pub use signal::resample_to;

pub use signal::welch;

pub use signal::SpectralWindow;

pub use signal::WelchConfig;

Modules

api

Public user-facing API for OxiFFT.

autodiff

Automatic differentiation for FFT operations.

chirp_z

Chirp-Z Transform (CZT) for arbitrary evaluation grids.

compat

FFTW Compatibility Layer for OxiFFT.

const_fft

Compile-time FFT with const generics.

conv

FFT-based convolution and polynomial multiplication.

dft

Complex DFT implementations.

frft

Fractional Fourier Transform (FrFT) implementation.

integrations

kernel

Core planner and data structures.

ntt

Number Theoretic Transform (NTT) — exact integer FFT over prime fields.

nufft

Non-uniform FFT (NUFFT) implementation.

pruned

Pruned FFT implementation for partial input/output computation.

rdft

Real DFT implementations.

reodft

Real Even/Odd DFT (DCT/DST) implementations.

signal

Signal processing functions built on FFT.

simd

SIMD abstraction layer for high-performance FFT computation.

sparse

Sparse FFT for k-sparse signals with a certified fast path.

streaming

Streaming FFT implementation for real-time processing.

support

Support utilities.

threading

Parallel execution support for multi-threaded FFT computation.

wasm

WebAssembly bindings for OxiFFT.