Push one complex sample and update all frequency bins.

Build a deterministic pseudo-random input vector of length `n` using f64.

Execute FFT with gather/scatter for non-contiguous data. The `fft_fn` closure receives contiguous input/output buffers and performs the actual FFT co

Check if bucket array is empty.

Clear the global twiddle cache, forcing recomputation on next access. Primarily intended for testing.

Execute the R2C FFT. # Arguments `input` - Real input of size N `output` - Complex output of size N/2+1 # Panics Panics if input size is not N or ou

reason: token-stream assembly requires many local variables

Get mutable bucket at index.

Return a buffer to the pool, evicting LRU entries if over budget. `buf.last_touched` is updated to `Instant::now()` before insertion so that freshly

Compute sparse FFT of a signal with at most k non-zero frequency components. This is the high-level API for one-shot sparse FFT computation. It auto

Compute Short-Time Fourier Transform (STFT). # Arguments `signal` - Input signal `fft_size` - Size of each FFT frame `hop_size` - Number of samples

Helper: prepare data in split-radix layout (E | O1 | O3) and compute expected result using the generic codelet, then compare against naive DFT. For t

Helper: evaluate a symbolic Expr with concrete f64 values for inputs.

Execute C2R FFT with normalization. The output is divided by N to give the true inverse of R2C.

Get or compute twiddle factors for the given size and direction (f64). Returns an `Arc` to the shared table. Subsequent calls with the same key hit t

Inverse NTT (in-place, includes 1/n scaling). After this call, `data` contains the original sequence (if it was previously transformed with [`forward

Calculate local partition for a given dimension.

Build a non-trivial complex input vector of length `n`.

Helper: max absolute error between two complex arrays.

Run the full parity check for a single (size, V, ISA) combo. `call_soa`: closure that calls the generated `_soa` function. Returns `Ok(())` if all V

reason: scalar fallback used on non-x86/non-aarch64 platforms and in tests

Execute the transform based on the configured kind.

Execute C2R transform.

Execute the 2D FFT in-place in parallel. # Panics Panics if buffer size doesn't match n0 x n1.

Execute the plan in-place. # Panics Panics if buffer size doesn't match the plan size. # Examples ``` use oxifft::{Complex, Direction, Flags, Plan}

Entry point for the `gen_dispatcher_codelet!` proc-macro. Parses `size = N, ty = TY` and calls [`generate_dispatcher`]. # Errors Returns a `syn::Er

Import wisdom from a string, with format version negotiation and per-entry validation. Entries that fail validation (zero hash, empty solver name, no

Run `f` inside the configured thread pool. When a custom pool is set, `f` is `install`ed into that pool so all rayon work spawned by `f` runs on the

Store wisdom for a size/solver combination.

Convenience function for 1D Real-to-Complex FFT. Takes N real values and produces N/2+1 complex values. The output satisfies conjugate symmetry: X\[k

SIMD-optimized Stockham FFT for f64 (radix-4 with radix-2 fallback). Uses radix-4 stage fusion for better performance (halves memory passes). Falls b

Build a deterministic pseudo-random input vector of length `n` using f32.

Compute `dst[i] = a[i] * b[i]` for AoS-layout `Complex<T>` slices. Dispatches to the concrete f64/f32 SIMD implementation based on `TypeId`. Falls ba

Convenience function for DCT-II transform.

Run the peeling decoder on bucket observations. # Arguments `bucket_stages` - Multiple stages of bucket observations # Returns Sparse result conta

Execute DCT-II using the Makhoul O(n log n) algorithm. Algorithm** (Makhoul 1980): Step 1 — rearrange x into complex y of length N: - `y[i] = x[

Simple hash for problem size.

Convenience function for 1D inverse FFT with normalization. Creates a plan, executes it, and normalizes by 1/N.

Import wisdom from a string. Entries with invalid data are skipped silently; the returned [`WisdomImportResult`] reports how many were imported and h

Build a non-trivial real input vector of length `n`.

Find next "smooth" number (product of small primes) for efficient FFT.

Apply the PFA (Good's index mapping) to compute DFT-N for N = n1 × n2 with gcd(n1,n2)=1. # Arguments `input` — read-only source slice of length N =