Return sorted assignments for temps used >= 2 times.

Return sorted assignments for temps used ≥ 2 times.

Generate Hamming window. `w[n] = 0.54 - 0.46 * cos(2πn/(N-1))`

Convenience function for 2D inverse FFT with normalization. Normalizes by 1/(n0 × n1).

Convenience function for parallel 2D inverse FFT with normalization. Normalizes by 1/(n0 x n1).

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

Convenience function for split-complex IFFT. Computes the inverse FFT of split-complex input, with normalization.

Compute the instantaneous frequency of a real signal. Returns the phase-difference sequence (with phase unwrapping), normalized to cycles per sample.

Check if a frequency has already been detected.

True if a wisdom line looks like a data entry (`(hash "solver" cost)`).

Simple primality test.

Validate that a [`WisdomEntry`] contains sensible data. An entry is considered invalid when: - `problem_hash == 0` - `solver_name` is empty - `cost`

Check if bucket is empty (zeroton).

Jacobian-vector product for FFT (used in forward mode AD). Computes J·v where J is the Jacobian of FFT and v is a vector. This is simply FFT(v) since

Generate Kaiser window. `w[n] = I₀(β * sqrt(1 - ((n - (N-1)/2) / ((N-1)/2))²)) / I₀(β)` where I₀ is the modified Bessel function of the first kind.

Locate the criterion `estimates.json` for a given group and bench name. Tries `current/` first (from `--save-baseline current`), then `new/`.

Ceiling of log₂(n). Returns 0 for n ≤ 1.

Compute magnitude spectrogram. # Arguments `spectrogram` - Complex spectrogram # Returns Magnitude of each bin `(|X[k]|)`.

Construct a synthetic dependency graph for scheduling tests. Chain A (depth 3, long critical path): a0 = x[0].re + x[1].re (depth 0 — leaf,

Compute `max |nufft[i] - ref[i]| / max(|ref[i]|)` over all `i`. Returns `0.0` if all reference values are near-zero.

Compute Mel-Frequency Cepstral Coefficients (MFCC). Applies a DCT-II to the log-mel spectrogram to decorrelate the features. This is the standard app

Reconstruct a minimum-phase signal from a real-valued input. The minimum-phase reconstruction works by: 1. Computing the real cepstrum of the input 2

Compute the modular inverse of `a` modulo `m` via extended Euclidean algorithm. Returns `Some(x)` where `a*x ≡ 1 (mod m)`, or `None` if gcd(a, m) !=

Naive O(N·M) CZT reference implementation (f64 only, for comparison).

Perform a forward NTT in-place. Creates a temporary [`NttPlan`] and applies the forward transform. For repeated transforms of the same size, prefer c

Execute function in parallel over range with chunking. Divides `count` iterations into chunks, each chunk processed by one thread. The function `f` r

Attempt to parse `(hash "solver" cost)` into a [`WisdomEntry`].

Parse the `mean.point_estimate` (nanoseconds) from `estimates.json`.

Pop the next available output frame (spectrum).

Power spectrum: |X\[k\]|² for each bin.

Find the smallest primitive root of a prime `p`. A primitive root `g` generates the entire multiplicative group (Z/pZ)*, meaning `g^k` for `k = 0, 1,

Generate `count` random f32 values.

Generate rectangular window (all ones).

Reduce angle to [-PI, PI] range.

Clear detected frequencies.

Rewrite an expression replacing shared subexpressions with `Temp` refs. Only extracts subexpressions used >= 2 times. Set `top_level_name` to `Some(n

Convenience function for parallel batched 1D Real-to-Complex FFT. Performs `howmany` independent R2C FFTs, each of size `n`, in parallel. Input batch

Compute inverse FFT using rustfft for reference.

Apply a scale factor to half-complex data. Scales all elements by the given factor.

Scatter elements from contiguous source to strided destination.

Fallback to standard FFT when sparse FFT is not beneficial.

Recursive split-radix DIF implementation. The split-radix algorithm uses a recursive structure: - X[k] for k even uses radix-2 decomposition - X[k] f

Synchronize CUDA device (no-op until GPU stream sync is active). # Errors This function currently cannot return an error; the `Result` signature is

Convert from oxifft Complex to `num_complex::Complex` for rustfft.

Total number of processes required (`n_rows * n_cols`).

Transform along a single dimension. For each "fiber" along dimension `dim_idx`, extract it, transform it, and place it back.

Transform along a single dimension in parallel. For each "fiber" along dimension `dim_idx`, extract it, transform it, and place it back.