Test forward/inverse roundtrip for a given size.

Upload data from CPU to GPU. Copies `data` into the CPU staging buffer. The actual GPU transfer happens inside `plan::execute()`. # Errors Returns

Validate that `inputs` and `outputs` are consistent for a batch FFT. Returns: - `Ok(0)` if the batch is empty (caller should return `Ok(())` immediat

In-place bit-reversal permutation. Uses byte-level lookup table for fast bit-reversal of indices.

Perform a distributed transpose of a 2D array. Transforms from row-major distribution to column-major distribution. After transpose, each process own

Execute batched FFT using Cooley-Tukey algorithm (for power-of-2 sizes). This is a convenience method that uses the optimal solver for power-of-2 siz

Execute the FFT on the Metal GPU. Input samples are converted from `Complex<T>` to `Complex<f32>` (Metal natively operates on f32), dispatched to the

Execute the N-dimensional FFT on the given input/output buffers. Data is in row-major order (last dimension varies fastest). # Panics Panics if buff

Execute NUFFT based on the configured type. # Errors Returns error for Type3 (use `execute_type3` instead) or if input validation fails.

Execute DCT-IV using the anti-symmetric 2N-point DFT algorithm. Algorithm (zero-padded 4N FFT extraction): Step 1 — zero-pad x to length 4N: - `y[n]

Convenience function for forward FFT using radix-8.

Run a full forward FFT and return the complete output vector.

Generate window coefficients for given size.

Generate test input data.

Small deterministic LCG for reproducible test inputs.

Naive O(n²) DFT reference for f64. `sign=-1` → forward, `sign=+1` → inverse.

2D NUFFT Type 1: Non-uniform to uniform. Given `M` non-uniform sample points `(xj, yj) ∈ [-π, π)²` with complex strengths `cj`, computes the 2-D DFT

Reference DFT for testing

Convert solver name to choice.

Generate the codelet `TokenStream`. # Errors Returns `CodegenError` if `n == 0` or code emission fails.

Compute linear convolution with specified output mode. # Arguments `a` - First signal `b` - Second signal (kernel) `mode` - Output mode (Full, Same,

Apply DFT-3 in-place on three elements at arbitrary indices.

reason: Winograd DFT-5 coefficients require full f64 precision

Execute the distributed 3D FFT out-of-place. Copies `input` to `output` then calls `execute_inplace`. # Errors - `MpiError::SizeMismatch` -- if eit

Execute the Fractional Fourier Transform. # Arguments `input` - Input signal # Errors Returns `FrftError::InvalidSize` if `input.len()` does not e

Execute the C2R FFT. # Arguments `input` - Complex input of size N/2+1 (conjugate symmetric) `output` - Real output of size N # Note The output is N

Execute using Cooley-Tukey for power-of-2 sizes.

Execute DCT-II transform (dispatches to fast for n >= 16 and even, direct otherwise).

Execute DCT-III using FFT-based O(n log n) algorithm (inverse of DCT-II). Uses the N-point conj-FFT-conj trick with Hermitian-symmetric input. The pl

Convenience function for forward FFT using split-radix.

Compute the Fractional Fourier Transform. # Arguments `input` - Input signal `order` - Fractional order α (α=1 gives standard DFT) # Errors Return

Entry point for the `gen_multi_transform_codelet!` proc-macro. Parses `size=N, v=V, isa=ISA, ty=TY` from the token stream and calls [`generate_multi_

Check if buffer is empty.

Naive DFT for correctness reference

Compute the periodogram power spectral density of a signal. Uses a Hann window internally. Returns a one-sided spectrum of length `signal.len() / 2

Real-valued twiddle post-processing for R2C. Given the N/2-point complex FFT output `Z[0..N/2]` of packed-real data, produces the correct N-point R2C

Convenience function for batched 1D Real-to-Complex FFT. Performs `howmany` independent R2C FFTs, each of size `n`. Input batches are contiguous (siz

Schedule assignment statements to maximise instruction-level parallelism (ILP). Algorithm (Sethi-Ullman critical-path heuristic): 1. Build a def-use

Compute overlap-save STFT analysis. The overlap-save (overlap-discard) method analyses a signal by sliding a window over the raw input with `n_overla

Assert two complex slices are approximately equal.

Collect all `Temp` variable names referenced in this expression.

reason: scalar fallback for non-x86 platforms; selected at runtime when AVX2/NEON unavailable

reason: scalar fallback for non-x86 platforms; selected at runtime when AVX2/NEON unavailable

Compute linear convolution of two real signals. The convolution `(a * b)[n] = Σ_k a[k] * b[n-k]` # Arguments `a` - First signal `b` - Second signal

Convenience function for Discrete Hartley Transform. The DHT is its own inverse (up to scaling by N): DHT(DHT(x)) = N * x

Convert half-complex format to complex format. # Arguments `halfcomplex` - Input in half-complex format (length n) `complex` - Output in complex form

Execute using Cooley-Tukey for power-of-2 sizes.

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

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

Execute in-place Cooley-Tukey FFT.

Execute batched FFT in-place using the provided 1D solver function.

Execute batched FFT using the provided 1D solver function. This is the core batch execution method that delegates to any 1D FFT implementation provid

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

Convenience function for forward FFT using radix-4.