Iterator over (index, value) pairs.

Add a frequency contribution to this bucket.

Execute the FFT. GPU kernel execution is pending oxicuda-launch integration. CPU FFT is used as the computation engine until then. # Errors Returns

Push a single sample.

Convenience function for 1D forward FFT. Creates a plan, executes it, and returns the result.

Execute the plan on the given input/output buffers. # Panics Panics if input or output buffer sizes don't match the plan size. # Examples ``` use o

Number of buckets.

Compute the complex conjugate of half-complex data. Negates all imaginary parts.

Append a dimension.

Forget all accumulated wisdom. Clears the global wisdom cache. Any subsequent planning will start fresh. # Example ```rust use oxifft::api::forget;

Generate a codelet `TokenStream` for size `n`. The emitted function is: ```ignore pub fn codelet_any_{n}<T: crate::kernel::Float>( x: &mut [crate::ke

Naive reference DFT. sign=-1 → forward, sign=+1 → inverse (un-normalized).

Get bucket at index.

Execute the sparse FFT. # Arguments `input` - Input signal (length n) # Returns `SparseResult` containing detected frequencies and values.

Generate test input data.

Get the number of valid samples.

Store a wisdom entry.

Get a mutable pointer to the raw storage.

Execute the cache-oblivious FFT. # Arguments `input` - Input array of complex values `output` - Output array (must be same length as input) `sign` -

Compute FFT using rustfft for reference.

Execute the pruned FFT. # Arguments `input` - Input data `output` - Output buffer For output-pruned: `input` should have length n, `output` should

Execute the Chirp-Z Transform. Writes `M` output samples into `output`. The method allocates two temporary length-`L` buffers internally (one alloca

Convenience function for forward FFT using DIT.

Execute the Cooley-Tukey FFT.

Forward NTT (in-place, decimation-in-time with bit-reversal). After this call, `data` contains the NTT of the input in standard order. # Panics Pan

Test FFT correctness for a given size.

Generate a multi-transform codelet `TokenStream`. # Output Always emits a public outer function `notw_{size}_v{v}_{isa}_{ty}` with `AoS` signature `

Download data from GPU to CPU. Copies from the CPU staging buffer (populated by `plan::execute()`) into `data`. # Errors Returns `GpuError::SizeMis

Execute DFT using the cached solver.

Execute the 2D FFT in parallel on the given input/output buffers. Input and output are row-major: element at (i, j) is at index i*n1 + j. # Panics P

Execute R2C transform.

Store a wisdom entry in the global cache. This is typically called internally by the planner after measuring algorithm performance.

Convenience function for batched 1D forward FFT. Performs `howmany` independent 1D FFTs, each of size `n`. Input and output are contiguous: batch `i`

Convenience function for forward DFT.