In-place transpose for non-square matrices. Uses cycle-following algorithm. This is O(n) in the number of elements but may have poor cache behavior f

Out-of-place transpose for rectangular N1×N2 matrix. Transposes N1×N2 row-major into N2×N1 row-major using a temporary buffer.

In-place blocked transpose for square N×N matrix stored in row-major order.

Attempt to build a Nufft plan with given oversampling, returning `None` if the combination is unsupported.

Try to factor `n` as a product of radices in `MIXED_RADIX_SUPPORTED`. Returns `Some(factors)` ordered innermost-first, or `None` if not possible.

Radix-4 DIT twiddle butterfly, forward. Layout: twiddles[(j-1)*stride + s] for j=1,2,3.

Radix-5 DIT twiddle butterfly, forward direction. `twiddles` must have length >= `4 * stride`.

Apply twiddle factors to `data` in-place: `data[i] *= twiddles[i]`. Dispatches to the best available SIMD backend at runtime: AVX2+FMA → SSE2 → NEON

Scalar SoA fallback for f32.

Scalar SoA fallback: `data[i] *= Complex { re: twiddle_re[i], im: twiddle_im[i] }`.

Apply SoA twiddle factors to `data` in-place (f32). Dispatches to the best available SIMD backend: AVX2 → SSE2 → NEON → scalar. # Panics Panics if

Apply twiddle factors from separate `twiddle_re`/`twiddle_im` SoA arrays to `data` in-place. Compared to the interleaved [`twiddle_mul_simd_f64`], th

Return the static f32 twiddle table for the size-16 FFT.

Return the static f64 twiddle table for the size-16 FFT.

Return the static f32 twiddle table for the size-32 FFT.

Return the static f64 twiddle table for the size-32 FFT.

Return the static f32 twiddle table for the size-64 FFT.

Return the static f64 twiddle table for the size-64 FFT.

Helper: compute max ULP distance between two f32 values.

Helper: compute max ULP distance between two f64 values.

Unwrap a phase sequence to be continuous (no jumps larger than π). Standard incremental phase unwrapping: for each step, the difference is wrapped ba

Vector-Jacobian product for FFT (used in reverse mode AD). Computes vᵀ·J where J is the Jacobian of FFT and v is a vector.

Add two half-complex arrays element-wise. result\[i\] = a\[i\] + b\[i\]

Derive an algorithm tag byte from a solver name string.

Variable all-gather operation. # Errors Returns `MpiError` on communication failure.

Variable all-to-all communication for complex data. Each process can send different amounts to different processes. # Errors Returns `MpiError` on c

Process a single frame and return spectrum. # Arguments `frame` - Input frame (must have length = fft_size) # Returns Complex spectrum of length f

Analyze bucket contents to detect singletons. Uses phase information from multiple subsampling stages to determine which buckets contain single frequ

Apply aliasing filter.

Apply filter to signal in time domain (convolution). This is less efficient than frequency domain multiplication. Use `apply()` on FFT of signal for

Absolute-floor relative tolerance check for SIMD f64 numeric comparison.

Compute gradient of a scalar loss with respect to IFFT input. For normalized IFFT: y = (1/N)·Fᴴ·x The adjoint of (1/N)·Fᴴ is (1/N)·F Gradient: ∂L/∂x

Choose a balanced factorization N = N1 × N2 where N1 ≈ √N. For power-of-2 N, we pick N1 = 2^(log2(N)/2) so both factors are as close to √N as possibl

Get the -3dB bandwidth of the filter.

If `bins` is a sorted, contiguous, unit-stride slice, return it as a `Range`.

Bit-reverse an index.

Compute bucket FFT for a stage.

Build the aarch64 dispatch branch for the cached dispatcher body. Size-16 has no NEON path.

Build the length-`L` circular-convolution filter `H_circ` for the CZT. The filter is `W^{-m²/2}` evaluated at indices `m = 0..M-1` and `m = 1..N-1` p

Compute `W^{k²/2}` for `k = 0 .. M`. # Returns A `Vec` of length `m`.

Compute `A^{-n} · W^{n²/2}` for `n = 0 .. N`. For on-unit-circle (|A|=1, |W|=1) inputs `Complex::cis` is used for maximum precision. For off-unit-ci

Build the aarch64 ISA detection body emitted inside the detect function.

Build the `x86_64` ISA detection body emitted inside the detect function.

Build the `x86_64` dispatch branches for the cached dispatcher body. For size-16 f32 only AVX-512 is available; for size-16 f64 no x86 SIMD path exis

Correctness guard: verify GPU output is within `tol` relative error of CPU.

Check if a bucket contains a singleton frequency.

Choose strategy for prefix (first m) bins.

Choose strategy for sparse (arbitrary) bins.

Clear all entries.

Clear the cache.

Column rank for a given global rank (0-indexed column in the 2D grid).

Calculate the COLA normalization factor for a window. This factor computes the sum of w^2 at position 0, which is what the overlap-add synthesis need

Collect per-gate results by reading criterion output.

Get collision probability estimate. Returns expected number of collisions for k sparse frequencies.

Compute bucket stages from input signal.

DFT of bin k from the current circular buffer.