Generate the generic split-radix twiddle codelet (L-shaped butterfly). The split-radix FFT decomposes an N-point DFT into: - One N/2-point DFT of eve

Generate a specialized 8-point split-radix twiddle codelet (fully unrolled). N=8: N/2=4 even, N/4=2 odd-1, N/4=2 odd-3. Unrolls the L-shaped butterfl

Emit the SSE2 f32, V=4, size-2 `SoA` multi-transform SIMD function. Processes 4 transforms of size 2 simultaneously using SSE2 `__m128` vectors. Each

Emit the SSE2 f32, V=4, size-4 `SoA` multi-transform SIMD function. Processes 4 transforms of size 4 simultaneously using SSE2 `__m128` vectors. # `

SSE2 size-2 butterfly on f64 data. Layout: `[re0, im0, re1, im1]` — each complex is one XMM register.

SSE2 size-2 butterfly on f32 data. `__m128` holds all 4 f32 lanes: [re0, im0, re1, im1]. Use 64-bit halves via shuffles to avoid crossing complex-num

SSE2 size-4 radix-4 butterfly on f64 data. Uses shuffle-based ±i rotation for the t3 term.

SSE2 size-4 radix-4 butterfly on f32 data. Each complex is 2 f32 lanes; a single `__m128` holds 2 complexes. We load data in two XMM registers: v01=[

SSE2 size-8 radix-2 DIT butterfly on f64 data.

Generate deterministic white noise in `[-1.0, 1.0]` using splitmix64.

Emit a function that delegates to `Plan::dft_1d` at runtime. Used for smooth-7 composites, runtime Rader primes, and Bluestein sizes — i.e., any size

Get the short git SHA of HEAD.

Get the global index range for this process's data.

Returns `true` when the (`ISA`, precision, size) combination has a true SIMD multi-transform implementation (`SoA` inner function). - SSE2 f32: sizes

Hash a hashable value.

Get individual hash functions.

Convenience function for inverse DFT with normalization (1/N factor).

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

Convenience function for inverse FFT using Bluestein (without normalization).

Convenience function for parallel N-dimensional inverse FFT with normalization. Normalizes by 1/(product of dimensions).

Convenience function for inverse FFT with normalization.

Interpolate from grid at non-uniform points.

Perform an inverse NTT in-place (includes 1/n scaling). # Errors Returns [`NttError`] if the length is not a power of two, the modulus is not prime,

Execute inverse FFT. # Arguments `real` - Real part of input (length must equal size) `imag` - Imaginary part of input (length must equal size) # R

Execute a complex-to-real inverse FFT on the Metal GPU. # Strategy Input is `n/2 + 1` complex bins (the positive-frequency half-spectrum). A full `n

Execute a complex-to-real inverse FFT. // KNOWN LIMITATION: CUDA R2C/C2R runs on CPU until oxicuda-launch kernel dispatch is integrated Wraps the ex

Inverse hash: find candidate frequencies that map to a bucket. Returns all frequencies in [0, n) that hash to the given bucket.

Convenience function for parallel batched 1D Complex-to-Real FFT with normalization. Performs `howmany` independent C2R FFTs, each producing `n` real

Check if a window satisfies the COLA condition for given hop size. COLA (Constant Overlap-Add) ensures that: Σ w[n + k*hop] = constant for all n

Check if bucket contains exactly one frequency (singleton).

Check if n is B-smooth (all prime factors <= B).

Inverse STFT using overlap-save synthesis. Given a spectrogram produced by [`stft_overlap_save`], reconstructs the time-domain signal. Each frame is

Get the number of detected frequencies.

Compute the squared magnitude of each complex component. For each frequency k: |X\[k\]|² = Re(X\[k\])² + Im(X\[k\])² Output is in the same half-compl

Build an empty `TokenStream`. Used for `gen_split_radix_twiddle_codelet!()` (no-arg generic variant).

Build `count` distinct inputs of length `n`.

Build a `TokenStream` for `gen_rdft_codelet!(size = N, kind = Hc2r)`.

Build a `TokenStream` for `gen_rdft_codelet!(size = N, kind = R2hc)`.

Maximum absolute error across all bins (f32).

Compute the median of a sorted slice of nanosecond timings. Requires `timings` to be sorted in ascending order.

Apply the mixed-radix digit-reversal (scatter) permutation in-place. For DIT with `factors` ordered innermost-first, consecutive blocks of `radix[0]`

Calculate modular multiplicative inverse using extended Euclidean algorithm.

Modular exponentiation: base^exp mod m.

Multiply two half-complex arrays element-wise (complex multiplication). Treats the half-complex data as complex numbers and performs element-wise com