Build a `TokenStream` containing a single integer literal `n`. Used as input to generators that accept `size = N` or just `N`.

Naive polynomial multiplication for reference (O(n²)).

Exact polynomial multiplication via NTT convolution. Computes the product of polynomials `a` and `b` over Z/pZ. The result has length `len(a) + len(b

Exact polynomial multiplication using the default prime (998244353). This is a convenience wrapper around [`ntt_convolve`] using [`NTT_PRIME_99824435

2D NUFFT Type 2: Uniform to non-uniform. Given a uniform `n1 × n2` grid of complex Fourier coefficients `f` (in row-major order), evaluates the 2-D i

Multiply two polynomials using FFT. Given polynomials `p(x) = Σ a[i] * x^i` and `q(x) = Σ b[i] * x^i`, computes their product r(x) = p(x) * q(x). #

Run `dispatch_chunked` with an identity dispatch function and assert that outputs match inputs.

Stage-fused Stockham implementation for f64 (scalar). Fuses pairs of radix-2 stages to halve memory passes, achieving radix-4 equivalent performance.

In-place square matrix transpose.

Radix-3 DIT twiddle butterfly, forward direction (exp(-2πi k/N)). `io` must have length >= `blocks * 3 * stride`. `twiddles` must have length >= `2 *

Scalar fallback: `data[i] *= twiddles[i]` with no SIMD.

Execute Type 2 NUFFT: uniform → non-uniform. Given uniform Fourier coefficients, evaluate at non-uniform points. # Errors Returns error if coeffici

Get access to the global wisdom cache for writing.

Allocate a cache-aligned buffer.

Bit-reversal permutation on a slice whose length is a power of two.

Drain all cached buffers, resetting the pool to an empty state. All GPU allocations held by the pool are freed when the buffers are dropped. This is

Compute magnitude-squared coherence between two signals. Coherence is defined as: ```text C[k] = |Cxy[k]|² / (Pxx[k] * Pyy[k]) ``` where `Cxy` is the

Compute `dst[i] = a[i] * b[i]` for AoS-layout `Complex<f32>` slices. Dispatches to the best SIMD backend available at runtime: AVX2+FMA → SSE2 → NEON

Compute `dst[i] = a[i] * b[i]` for AoS-layout `Complex<f64>` slices. Dispatches to the best SIMD backend available at runtime: AVX2+FMA → SSE2 → NEON

Count operations in a set of (re, im) expression pairs after CSE rewriting.

Get a mutable reference to the CPU staging data.

Compute the cross-spectral density (CSD) between two signals using Welch's method. For each segment the windowed FFT is computed for both `x` and `y`

Emit a scalar `Expr` for R2HC. `Input { index, is_real: true }` → `x{index}` (real input) `Input { index, is_real: false }` → should not occur in R2H

Emit a single scalar `Expr` as a `TokenStream`.

Execute the distributed FFT out-of-place. # Errors Returns `MpiError::SizeMismatch` if input buffer is too small.

Execute the plan. # Panics Panics if buffer sizes don't match the plan size.

Execute DCT-I using FFT-based O(n log n) algorithm. Even extension of length 2(N-1): v\[i\] = x\[i\] for i = 0..N-1 v\[i\] = x\[2(N-1)-i\]

Execute DHT using FFT-based O(n log n) algorithm. For real input x: Y = FFT(x) (complex FFT with zero imaginary parts) DHT\[k\] = Y\[k\].re - Y\[k\]

Execute DST-I using FFT-based O(n log n) algorithm. DST-I of length N via 2(N+1)-point odd extension: Build v of length 2(N+1): v\[0\] = 0, v\[n+1\]

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

Execute DST-II using FFT-based O(n log n) algorithm. Relationship: DST_II(x)\[k\] = DCT_II(y)\[N-1-k\] where y\[n\] = (-1)^n * x\[n\] (sign-alternat

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

Execute DST-III using FFT-based O(n log n) algorithm. Relationship: DST_III(f)\[n\] = (-1)^n * DCT_III(f_reversed)\[n\] where f_reversed\[k\] = f\[N-

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

Execute DST-IV using FFT-based O(n log n) algorithm. Relationship: DST_IV(x)\[k\] = (-1)^k * DCT_IV(x_reversed)\[k\] where x_reversed\[n\] = x\[N-1-n

Execute Rader's FFT with provided work buffers.

Execute the Bluestein FFT with provided work buffers. All three work buffers must have length `m` (the padded size).

reason: mixed-radix solver requires 6 pre-allocated work buffers; grouping into struct would add unnecessary allocations

Extended Euclidean algorithm. Returns (gcd, x, y) such that a*x + b*y = gcd.

Feed new samples into the processor. Returns the number of complete frames available.

Convenience function for parallel 2D forward FFT. Input is row-major with n0 rows and n1 columns.

Convenience function for forward FFT using Bluestein.

Convenience function for N-dimensional forward FFT. Input is in row-major order.

Compute FFT when only some inputs are non-zero. This is efficient when the number of non-zero inputs is small. Uses direct DFT computation for sparse

Convenience function for split-complex FFT. Computes the forward FFT of split-complex input.

Compute FrFT with error handling. # Errors Returns `FrftError::InvalidSize` if `input` is empty, or `FrftError::PlanningFailed` if FFT planning fail