Generate a split-radix twiddle codelet for the given size. If no size is specified (empty input), generates the generic runtime-parameterized split-r

Get or compute twiddle factors for size n and radix k. Returns W_n^0, W_n^1, ..., W_n^(k-1) for the given parameters.

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

Deterministic Miller-Rabin primality test for all `u64` values. Uses a set of witnesses that is sufficient to deterministically test any 64-bit integ

Merge incoming wisdom into the global cache. For each entry in the incoming wisdom string: - If the problem hash is not yet in the global cache, it i

Merge incoming wisdom into this cache. For every entry in `s`: - If the hash is absent from the cache, insert it. - If the hash is present but the in

Pack N reals into N/2 complex, compute naive complex DFT.

Apply `f` to non-overlapping mutable slices of `data`, each of length `chunk_size` (the last slice may be shorter), in parallel using rayon. When a c

Compute the real cepstrum of a signal. The real cepstrum is defined as `IFFT(log(|FFT(x)|))`. Because only the log-magnitude is used (phase is discar

Helper: brute-force DFT of a complex slice (reference implementation).

Reference O(n²) DFT for verification.

Resample a real signal to a new length using spectral interpolation/decimation. Uses FFT-based frequency-domain resampling: - **Upsampling** (`new_le

Rewrite an output expression (replacing shared subexpressions with Temp refs).

Scalar Stockham implementation for f64 (radix-2, for reference/testing). Uses pre-computed twiddle factors per stage for efficiency.

Out-of-place matrix transpose.

Execute Type 1 NUFFT: non-uniform → uniform. Given values at non-uniform points, compute uniform Fourier coefficients. # Errors Returns error if in

Compute power spectral density using Welch's method. Divides the signal into overlapping segments, applies a window to each, computes the FFT, and av

Compute gradient of a scalar loss with respect to FFT input (backward mode AD). Given the gradient of loss w.r.t. FFT output (grad_output), computes

Modified Bessel function of the first kind, order 0. Uses polynomial approximation.

For a given size, verify SoA vs AoS within 4 ULP (f32).

For a given size, verify that applying AoS and SoA twiddle multiplication to the same input produces results within 4 ULP of each other (f64).

Classify `n` for codelet generation. # Errors Returns `CodegenError::InvalidSize(0)` when `n == 0`.

Clear the buffer.

Compute kernel width based on desired tolerance and oversampling ratio. The spreading kernel is `exp(-β·(j/W)²)` with `β = 2.3·W` and `W = kernel_wid

Compute offset for multi-dimensional index.

Compute linear convolution with specified output mode.

Count usages of each subexpression across all outputs (bottom-up).

Create optimal filter for sparse FFT based on sparsity. # Arguments `n` - Signal length `k` - Expected sparsity `num_buckets` - Number of buckets

Dispatch a batch of FFTs, automatically splitting into chunks of at most `chunk_limit` elements. When `inputs.len() <= chunk_limit` the outer loop ex

Execute the FFT with buffering for non-contiguous access. Uses a contiguous buffer to improve cache locality when strides are non-unit.

Execute the direct DFT computation. # Arguments `input` - Input array of complex values `output` - Output array (must be same length as input) `sign`

Execute the guru plan on the given buffers. # Arguments `input` - Input buffer with layout matching `dims` and `howmany` `output` - Output buffer wit

Execute DCT-II (REDFT10) using direct O(n²) computation. Formula: X\[k\] = sum_{n=0}^{N-1} x\[n\] * cos(π * (2n + 1) * k / (2N))

Execute DCT-III transform (dispatches to fast for n >= 16, direct otherwise).

Execute DCT-IV (REDFT11) using direct O(n²) computation. Formula: X\[k\] = sum_{n=0}^{N-1} x\[n\] * cos(π * (2n + 1) * (2k + 1) / (4N))

Execute Discrete Hartley Transform (DHT) using direct O(n²) computation. Formula: H\[k\] = sum_{n=0}^{N-1} x\[n\] * cas(2πnk/N) where cas(θ) = cos(θ

Decimation-in-Time in-place.

Execute DST-I (RODFT00) transform. Formula: X\[k\] = sum_{n=0}^{N-1} x\[n\] * sin(π * (n+1) * (k+1) / (N+1)) Note: DST-I is always computed directly

Execute the FFT using explicitly supplied buffers. This is the `&self` companion to `execute_internal`. It creates no allocations beyond the caller-s

Compute FFT for only selected output frequencies. This is efficient when you need fewer than log₂(N) outputs. For more outputs, consider using full F

Execute a 1-D complex DFT plan. Corresponds to FFTW's `fftw_execute` / `fftw_execute_dft`. Unlike FFTW, OxiFFT does not modify the input buffer. The

Execute forward FFT.

Compute 1-D Gaussian kernel weights for a single non-uniform point. Returns a `Vec` of `(grid_index, weight)` pairs. The grid is of size `n_grid` an

Generate an odd-size (3, 5, 7) DFT codelet from macro input `gen_odd_codelet!(N)`. # Errors Returns `syn::Error` if the input is not a valid integer

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

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

Compute DFT for a single frequency using the Goertzel algorithm. This is efficient when only one or a few frequencies are needed. Complexity: O(N) pe

Compute multiple DFT frequencies using Goertzel algorithm. More efficient than full FFT when computing fewer than log₂(N) frequencies. # Arguments

Compute the analytic signal via the Hilbert transform. Returns a complex-valued vector of the same length as `signal`. The real part of the analytic

Convenience function for batched 1D inverse FFT with normalization. Performs `howmany` independent 1D inverse FFTs, each of size `n`. Normalizes each

Compute Inverse Short-Time Fourier Transform (ISTFT). Reconstructs a time-domain signal from a spectrogram using overlap-add. # Arguments `spectrog

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