Execute the distributed FFT in-place. Input layout: `data[row * n1 + col]` where `row` is local (0..local_n0). Output layout depends on `transposed_o

Execute the distributed 3D FFT in-place. Input/output layout: `data[i0 * local_n1 * n2 + i1 * n2 + i2]` where `i0 in [0, local_n0)`, `i1 in [0, local

Execute input-pruned FFT.

Execute for integer order (0, 1, 2, 3).

Execute the multi-rank 3D pencil FFT (called when `row_pool.is_some()`). Algorithm (Z→Y→X): 1. Z-FFT: local, on the `[local_n0, local_n1, n2]` slab.

Execute an N-dimensional transform using row-column decomposition.

Output-pruned: Goertzel on bins 0..m.

Execute output-pruned FFT.

Execute row FFTs on an N1×N2 matrix stored in row-major order. For each row i (0..N1), the elements are contiguous: matrix[i*N2 .. (i+1)*N2].

Simplified execute for cases where input_base and output_base are 0.

Split-radix FFT out-of-place. Implements the split-radix FFT algorithm which combines radix-2 and radix-4 decompositions to achieve near-optimal oper

Split-radix FFT in-place.

Execute Type 3 NUFFT: non-uniform → non-uniform. # Arguments `values` - Values at source points (set during plan creation) `target_points` - Target

reason: helper for mod_inv; not called when modular inverse path is inactive

Return the distinct prime factors of `n`.

Execute a 3D FFT on a flat C-contiguous array of shape `[n0][n1][n2]`. Uses three passes of 1-D FFTs: first along dimension 2 (innermost), then dimen

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

Convenience function for in-place forward FFT using Bluestein.

Compute FFT with forward-mode automatic differentiation. Returns (output, output_tangent) where output_tangent is the directional derivative of FFT i

reason: public API for input-pruned FFT; not all call sites are compiled in every feature configuration

reason: public API for output-pruned FFT; not all call sites are compiled in every feature configuration

Convenience function for in-place forward FFT.

Convenience function for in-place forward FFT using radix-4.

Convenience function for in-place forward FFT using radix-8.

Convenience function for in-place forward FFT using split-radix.

Destroy (free) a 1-D DFT plan. Corresponds to FFTW's `fftw_destroy_plan`. In OxiFFT this is a no-op: Rust's ownership system automatically frees the

Count how many fiber coordinates are "below" dimension d (excluding dim_idx).

Count how many fiber coordinates are "below" dimension d (excluding dim_idx).

Compute the starting index for a fiber along dimension `dim_idx`. Given a linear fiber index, compute the base index in the flat array.

Compute the starting index for a fiber along dimension `dim_idx`. Given a linear fiber index, compute the base index in the flat array.

Fill buckets from subsampled FFT result. # Arguments `subsampled_fft` - FFT of subsampled signal (length = num_buckets)

Filter frequencies by minimum magnitude threshold.

Find singleton buckets across all stages.

Execute forward FFT with interleaved input. # Arguments `interleaved` - Interleaved complex input [re0, im0, re1, im1, ...] # Returns Interleaved

Forward NTT, out-of-place. Copies `input` into `output`, then performs the forward transform on `output`. # Panics Panics if `input.len() != self.n

Execute a real-to-complex forward FFT on the Metal GPU. # Strategy Real input is zero-extended to complex (imaginary parts = 0), then a full C2C for

Execute a real-to-complex forward FFT. // KNOWN LIMITATION: CUDA R2C/C2R runs on CPU until oxicuda-launch kernel dispatch is integrated Wraps the ex

Gather N-dimensional data into contiguous buffer.

Calculate GCD using Euclidean algorithm.

Greatest common divisor.

Emit the AVX2 f32, V=8, size-2 `SoA` multi-transform SIMD function. Processes 8 transforms of size 2 simultaneously using AVX2 `__m256` vectors. Each

Emit the AVX2 f32, V=8, size-4 `SoA` multi-transform SIMD function. Processes 8 transforms of size 4 simultaneously using AVX2 `__m256` vectors. # `

AVX2+FMA size-2 butterfly on f64 data. Loads both complexes as a single 256-bit vector, splits into 128-bit halves, butterflies, and stores as a sing

AVX2+FMA size-2 butterfly on f32 data. Size-2 f32 data is only 4×f32 = 128 bits — cannot fill a 256-bit YMM. We use 128-bit SSE `_ps` intrinsics unde

AVX2+FMA size-4 radix-4 butterfly on f64 data. Uses 256-bit operations for the pair-wise stages: - `v_01` = [x0, x1], `v_23` = [x2, x3] (each 256 bit

AVX2+FMA size-4 radix-4 butterfly on f32 data. A single `__m256` holds 4 complexes as 8 f32 lanes: [re0,im0,re1,im1,re2,im2,re3,im3].

AVX2+FMA size-8 radix-2 DIT butterfly on f64 data. Uses 256-bit loads/stores and FMA for twiddle application.

AVX-512F size-2 butterfly on f32 data. Size-2 f32 data is only 4 f32 = 128 bits. Uses XMM operations under the `avx512f` feature umbrella (same as AV

AVX-512F size-2 butterfly on f64 data (radix-2 DIT). Holds 4 complex f64 pairs in one ZMM: [re0,im0,re1,im1,re2,im2,re3,im3]. Processes 4 simultaneou

AVX-512F size-4 radix-4 DIT butterfly on f32 data. One ZMM holds 8 complex f32 = 16 f32 lanes: [re0,im0,...,re7,im7]. We process 8 simultaneous size-

AVX-512F size-4 radix-4 DIT butterfly on f64 data. One ZMM holds 4 complex f64: [re0,im0,re1,im1,re2,im2,re3,im3]. We load both halves (x0..x1 and x2

Pure-AVX size-2 butterfly on f64 data. Loads both complexes as a single 256-bit vector, splits into 128-bit halves, butterflies, and repacks via `_mm

Pure-AVX size-4 radix-4 butterfly on f64 data. Uses 256-bit loads and pure-AVX permutation to perform the two butterfly stages. The ±i rotation on t3

Generate the dispatcher for size-16 (f32 only via AVX-512F; scalar fallback). Size-16 is only available as f32 via AVX-512F. All other paths fall thr

NEON size-2 butterfly on f64 data.

NEON size-2 butterfly on f32 data. Uses `float32x2_t` (2 lanes = 1 complex) for clean structural match with the f64 path.

NEON size-4 radix-4 butterfly on f64 data.

NEON size-4 radix-4 butterfly on f32 data. Uses `float32x2_t` — 1 complex per register, mirrors f64 structural layout.

NEON size-8 radix-2 DIT butterfly on f64 data.

NEON size-8 radix-2 DIT butterfly on f32 data. Uses `float32x2_t` — 1 complex per register, mirrors the f64 path exactly.

Build the outer `AoS` function body for any config (scalar loop over all transforms). The outer function always processes transforms sequentially (sc

Emit the scalar butterfly body for a single transform of `size`. The body references `input`, `output`, `istride`, `ostride`, `base_in`, `base_out` f

Emit a size-2 radix-2 butterfly body. `out[0] = x[0] + x[1]`, `out[1] = x[0] - x[1]`.

Emit a size-4 radix-4 DIF butterfly body (forward sign). Stages: t0=x0+x2, t1=x0-x2, t2=x1+x3, t3=x1-x3. Forward rotation: `t3 *= -i` → `(im, -re)`.

Scalar size-2 butterfly (generic over any Float type).

Scalar size-4 radix-4 butterfly (generic).

Scalar size-8 radix-2 DIT butterfly (generic).

Emit the inner `SoA` SIMD function `TokenStream` for the given config. Returns `None` if the config has no SIMD implementation.

Generate size-16 SIMD radix-2 DIT codelet (f32 only via AVX-512F). Size-16 FFT: radix-2 DIT with 4 butterfly stages. SIMD strategy: - AVX-512F (`x86

Generate size-2 SIMD butterfly codelet. Size-2 butterfly: out[0] = a + b, out[1] = a - b SIMD strategy: - AVX-512F (`x86_64`): 256-bit YMM under avx

Generate size-4 SIMD radix-4 codelet. Size-4 FFT: radix-4 butterfly with sign-dependent ±i rotation. SIMD strategy: - AVX-512F (`x86_64`): 256-bit f

Generate size-8 SIMD radix-8 codelet. Size-8 FFT: radix-2 DIT with 3 butterfly stages. SIMD strategy: - AVX-512F (`x86_64`): 256-bit + FMA via ZMM p