Compute an aligned-capacity SoA f32 twiddle table directly from cos/sin.

Compute an aligned-capacity SoA f64 twiddle table directly from cos/sin. Capacity is rounded up to the next multiple of 8 so that SIMD loads reading

Compute linear convolution of two complex signals.

Compute cross-correlation of complex signals with mode.

Compute cross-correlation with specified mode.

Get the CPU brand string.

Get subsampling factors based on Chinese Remainder Theorem. Returns a set of coprime factors for CRT-based subsampling.

Convenience function for DCT-I transform.

Scalar reference implementation of DCT-II for validation.

Convenience function for DCT-III transform (inverse DCT-II).

Convenience function for DCT-IV transform.

Scalar reference implementation of DCT-IV for validation.

Execute DCT-I.

Execute DCT-II (the standard DCT).

Execute DCT-III (inverse of DCT-II).

Execute DCT-IV.

Handle full-density case (k >= n) by reading all significant buckets directly from the first bucket stage.

Demonstrate 2D NUFFT (new in v0.3.0): non-uniform 2D points → uniform 2D grid.

Demonstrate Type 3 NUFFT: non-uniform source → non-uniform target.

Dense NDFT Type 1 (non-uniform → uniform, O(N*M)). `f_hat[k] = sum_{j=0}^{M-1} c[j] * exp(-i * freq * x[j])` where `freq ∈ [-N/2, N/2)` and `k` goe

Dense NDFT Type 2 (uniform → non-uniform, O(N*M)). `f[j] = sum_{k=-N/2}^{N/2-1} f_hat[k] * exp(i * freq * x[j])` Grid sizes ≤ 256, so casts through

Simple singleton detection for a single bucket observation. Uses magnitude-based detection with threshold.

Naïve O(N²) forward DFT (sign = -1) of `input`, result into `output`.

Execute the Discrete Hartley Transform. The DHT is its own inverse (up to scaling).

reason: &mut self needed for future multi-rank transpose plans; API consistency

reason: NEON SIMD stage variables require uninitialized-then-branch pattern for correct register allocation

Scalar DIT butterfly stages (for non-f64 types). Uses twiddle recurrence to avoid repeated sin/cos calls.

DIT butterfly stages for f32 using SoA precomputed twiddle tables.

DIT butterfly stages for f64 using SoA precomputed twiddle tables. For transforms of size >= 4096, the twiddle tables are large enough that the SoA l

Convenience function for DST-II transform.

Convenience function for DST-III transform (inverse DST-II).

Convenience function for DST-IV transform.

Execute DST-I.

Execute DST-II.

Execute DST-III.

Execute DST-IV.

Emit the inner body statements from constant-folded and CSE-optimized outputs. Emits: - input extraction: `let x{i}_re = x[{i}].re; let x{i}_im = x[{

Build the body for HC2R.

Emit the full HC2R codelet function as a `TokenStream`.

Build the body for R2HC.

Emit the full R2HC codelet function as a `TokenStream`.

Ensure we have at least `byte_count` bytes available. Grows but never shrinks.

Estimate frequency using Chinese Remainder Theorem.

Estimate frequency from phase difference between two subsampling stages. Uses the Chinese Remainder Theorem to recover the original frequency from al

Estimate the computational complexity. Returns estimated number of operations.

Remove old pool entries until `needed` bytes of headroom are available. Caller must hold the `inner` lock.

Execute Stockham FFT (out-of-place). The output is in natural order (no bit-reversal needed).

Execute the partial FFT. # Arguments `input` – Input samples; length must equal `n` used at construction. `output` – Output buffer; length must mat

Execute a 1D transform with arbitrary strides.

Execute using the best available solver for the size.

Execute batched transforms.

Execute dual-pruned FFT.

Execute batched C2R (complex-to-real) FFT with normalization. For each batch, takes n/2+1 complex values and produces n real values. Output is normal

Execute column FFTs on an N1×N2 matrix stored in row-major order. For each column j (0..N2), gather elements at stride N2, perform FFT of size N1, an

Execute in-place using Cooley-Tukey.

Fallback DCT-II when no cached plan is available for the input size.

Fallback DCT-III using 2N-point FFT (when no cached plan matches).

Fallback DCT-IV using 4N-point zero-padded approach.

Decimation-in-Frequency out-of-place.

Decimation-in-Frequency in-place.

Decimation-in-Time out-of-place.

Radix-4 DIT out-of-place. Implements a true radix-4 FFT that reduces multiplications by ~25% compared to radix-2. Uses standard bit-reversal followed

Radix-4 DIT in-place.

Radix-8 DIT out-of-place. Implements a radix-8 FFT that combines three radix-2 stages into one, providing further optimization for sizes divisible by

Radix-8 DIT in-place.

Execute fractional order transform using chirp decomposition.

Full FFT then copy the requested range into output.

Delegate Goertzel computation to the existing (tested) implementation.

Execute Rader's FFT in-place. Uses the pre-allocated `work_inplace` buffer when available (avoids an unconditional `data.to_vec()` allocation in the

Execute in-place cache-oblivious FFT.

Execute in-place direct DFT computation. Uses O(n) additional memory for temporary storage.

Execute batched FFT in-place.

Execute in-place mixed-radix FFT.

Execute the distributed FFT in-place. Input layout: `data[i0 * n1 * n2 + i1 * n2 + i2]` where `i0` is local. # Errors Returns `MpiError::SizeMismatc

Execute the distributed N-D FFT in-place. For dimensions 1-3, delegates to optimized implementations. For higher dimensions, uses a general row-major