Split FFT Algorithm

• Split FFT algorithms are methods that partition DFT/FFT computations for improved memory management and computational efficiency.
• They enable selective computation and tailored coefficient processing, achieving up to 21× speedup in scenarios like partial Fourier transforms.
• Leveraging recursive embedding and parallel processing, these algorithms reduce arithmetic complexity while enhancing scalability and hardware optimization.

The Split Fast Fourier Transform (Split FFT) algorithm refers to a class of methodologies that structurally partition the computation of the discrete Fourier transform (DFT) or fast Fourier transform (FFT) to enable flexible memory use, tailored coefficient selection, or hardware-optimized computations. Recent research emphasizes three principal directions for Split FFTs: “lazy embedding / eager projection” for block Toeplitz operations, selective computation of Fourier coefficients (“Partial FFT”), and splitting real and imaginary data paths to optimize low-level implementation and post-processing. Each variant targets specific computational bottlenecks or application requirements, achieving substantial reductions in memory footprint, arithmetic complexity, and communication overhead under suitable geometry and workload.

1. Lazy Embedding and Eager Projection for Block Toeplitz Multiplication

The Split FFT algorithm for block Toeplitz matrix-vector multiplication circumvents the high memory and arithmetic cost inherent in classic circulant embedding approaches. In standard multilevel embedding, a $d$-dimensional block-Toeplitz matrix $T\in\mathbb{C}^{n^d\times n^d}$ is embedded within a $(2n)^d$-sized circulant matrix, which is then diagonalized via FFTs, but this process introduces $2^d$ overhead in both data movement and memory.

The Split FFT variant, as presented in (Siron et al., 2024), employs recursive “lazy” embedding, deferring each doubling of the dimension—and the associated padding and twiddle arithmetic—until immediately before the corresponding one-dimensional FFT at each recursion level. Each transformed vector is split into “even” and “odd” (phase-shifted) branches; the Toeplitz diagonal multiplication is performed only at the leaves of the recursion, after all FFTs, and the two branches are merged with an inverse FFT and phase conjugation, discarding extraneous padding as soon as it is feasible.

This recursive, tree-structured approach imposes no requirement to ever form the full circulant matrix, and only ever constructs two $n^d$-sized images at each level. The memory requirement reduces from $2^{d+1}n^d$ (full method) to $(d+1)n^d+2^dn^d$, with further improvement to $(2^d+1)n^d/(d+2)$ in symmetric or skew-symmetric cases. The arithmetic cost is asymptotically reduced by a factor of $d/(2-2^{-(d-1)})$ compared to the standard method. The algorithm is naturally parallelizable: every branch at recursion level $k$ is independent and can be mapped to separate compute threads or devices, minimizing cross-communication and leveraging hardware accelerators such as multi-GPU clusters with minimal synchronization. Empirical results demonstrate speedups of $1.3\times$ ($d=2$), $1.7\times$–$2.1\times$ ($d=3$), and increasing advantage for higher dimensions, with practical gains aligned with theoretical prediction (Siron et al., 2024).

2. Partial Fourier Transform: Selective (Split) Spectrum Computation

In cases where only a small, consecutive interval of DFT frequencies is required, the Split FFT can refer to the Partial Fourier Transform (PFT), as developed in (Park et al., 2020). The algorithm is a modification of the Cooley–Tukey FFT: the computation is “split” such that only the desired coefficients $m\in[\mu-M,\mu+M]$ are produced, rather than the entire spectrum, thus avoiding unnecessary arithmetic and memory use.

The derivation partitions the input of size $N=pq$ and rewrites the DFT sum to concentrate the slow-varying twiddle factor, which admits accurate polynomial approximation when the output interval is sufficiently narrow. The algorithm proceeds with a sequence of three main operations: matrix multiplication ($O(rN)$), $r$ forward FFTs of size $p$ ($O(rp\log p)$), and, for each coefficient, an $r$-term inner product ($O(rM)$). When $M\ll N$ and for fixed accuracy, the runtime reduces to $O(N+M\log M)$—offering up to $21\times$ speedup over full-spectrum FFT routines when $M/N<0.1$, as substantiated by direct comparisons to FFTW and Intel MKL benchmarks. The absolute error can be rigorously bounded by $\|a\|_1\epsilon$, with polynomial approximation order $r$ controlling the tolerance.

Guidelines established by (Park et al., 2020) recommend the Split/Partial FFT when $M/N\lesssim 0.1$; for broader spectrum computation $(M/N\gtrsim0.3)$, a traditional FFT becomes preferable.

3. Real-Arithmetic Split FFT for Complex Inputs/Outputs

A third principal form of Split FFT refers to an algorithmic refactoring in which complex-valued DFT computations are restructured into $2N \times 2N$ real-arithmetic form, supporting separate real and imaginary input and output streams. This approach is essential when downstream signal processing requires real and imaginary parts to be handled independently and enables improved vectorization or memory locality.

In (Cariow, 9 Apr 2025), the complex DFT

$y_k = \sum_{n=0}^{N-1} x_n e^{-j2\pi nk/N}$

with $x_n = x_n^{(r)} + jx_n^{(i)}$ is decomposed into paired real summations,

$$y_k^{(r)} = \sum_{n} [x_n^{(r)}\cos + x_n^{(i)}\sin], \qquad y_k^{(i)} = \sum_{n} [x_n^{(i)}\cos - x_n^{(r)}\sin]$$

and assembled in block vector form as $y = E_{2N} \cdot x$, where $E_{2N}$ is a structured real matrix. The factorization of $E_{2N}$ mirrors the Cooley–Tukey decimation-in-time structure but operates exclusively in real arithmetic with explicit separation of real/imaginary channels. The butterfly and twiddle-multiply stages are expressed as $2\times2$ real matrix operations, and the full algorithm maintains the same asymptotic arithmetic complexity as standard complex FFT—$O(N\log_2 N)$ real operations.

This Splitting supports in-place execution, facilitates SIMD optimization, and enables direct compatibility with real/imaginary-separated post-processing pipelines. Implementation requires only a single $2N$-length real array and $O(N)$ twiddle-storage, with stages mapped readily to parallel hardware. The Split form does not inherently reduce the operation count but aligns the dataflow to system and application-specific post-processing requirements and can simplify codebases needing fully separated channels (Cariow, 9 Apr 2025).

4. Theoretical Complexity and Memory Characteristics

The Split FFT modalities provide complexity and memory improvements contingent on the adopted structure and target use case:

Split FFT Type	Time Complexity	Peak Memory Requirement
Lazy embedding (block Toeplitz)	$O(d\,n^d\,\log n)$	$(d+1)n^d+2^dn^d$
Symmetric Toeplitz (Split-FFT)	As above	$(2^d+1)n^d/(d+2)$
Partial FFT (PFT)	$O(N+M\log M)$ for $M\ll N$	$O(N)$
Split real/imag FFT	$O(N\log N)$ real ops	$2N$ real workspace

In the block Toeplitz context, the arithmetic cost reduction is by a factor that asymptotically approaches $d/(2-2^{-(d-1)})$; memory usage is reduced by a corresponding factor, with further improvement for symmetric cases (Siron et al., 2024). For Partial FFT, complexity depends on the output window width and never exceeds $O(N\log N)$. The real/imag split incurs no complexity cost but enables data management optimizations (Cariow, 9 Apr 2025).

5. Parallelization and Practical Implementation

All Split FFT algorithms surveyed are amenable to high-throughput parallelization:

• Tree-structured recursion (lazy embedding): Each branch is independent during FFT and diagonal multiplication stages, only requiring communication at merge points. Workload can be distributed across threads, CPU cores, or GPUs. Each active branch maintains local memory, simplifying synchronization (Siron et al., 2024).
• Partial FFT: The main matrix multiply and the set of restricted-size FFTs are blockwise and parallelizable. Post-processing for each target frequency can be independently executed (Park et al., 2020).
• Real and imaginary separation: Blocks can be mapped onto vector hardware (SIMD), and butterfly stages can be distributed in parallel. The interleaving layout supports cache-efficient processing, and the algorithm is amenable to both CPU and GPU implementation (Cariow, 9 Apr 2025).

All approaches leverage existing performant one-dimensional FFT kernels (e.g., FFTW, MKL, cuFFT) without modification. The only specialized requirement is the management of branch-specific phase shifts and diagonal multiplications in recursive schemes or packing/unpacking in real/imaginary-split transformations.

6. Applications and Performance Benchmarks

Split FFT algorithms target specific high-performance challenges:

• Electromagnetic and acoustic modeling: Large, dense block Toeplitz products as required for Green’s function evaluation or wave simulations benefit from the lazy-embedding Split FFT, with wall-clock speedups up to $2.1\times$ for 3D geometries, increasing with $d$ (Siron et al., 2024).
• Spectral feature extraction and anomaly detection: When only a small fraction of DFT coefficients is needed, the PFT Split FFT offers up to $21\times$ speedup on synthetic data and $8\times$ on real-world signals for $M/N < 0.1$ (Park et al., 2020).
• Signal pipelines with independent real and imaginary processing: Real-valued Split FFT facilitates efficient channel processing and memory layout in hardware or software systems, with unchanged computational cost but with reduced implementation complexity and improved vectorization (Cariow, 9 Apr 2025).
• Large parallel scientific computing: Variants applied to three-dimensional FFT grid partitioning improve scalability and load balancing in electronic-structure calculations (Gao et al., 2016).

For all forms, algorithmic correctness and error are rigorously characterized in the foundational work: polynomial approximation controls PFT’s absolute error, while phase-shift operator management preserves the DFT’s algebraic properties in block Toeplitz and real/imaginary splitting settings.

7. Significance, Limitations, and Outlook

Split FFT algorithms offer significant advances in computational efficiency, memory management, and practical implementation flexibility for large-scale, structured, or selectively-computed DFTs. Their recursive or data-split nature aligns well with parallel hardware, and they are adaptable to real-world applications demanding scalable high-performance transforms or fine-grained Fourier feature selection.

A plausible implication is that split-style algorithms will become increasingly integral in exascale scientific computing and real-time signal-processing, particularly as data locality and hardware occupancy become limitations. However, the advantages are most pronounced when application geometry aligns with the split structure (e.g., block Toeplitz, windowed coefficients, channel splitting); for generic or unstructured transforms, traditional Cooley–Tukey style FFTs remain efficient.

Theoretical development and open-source implementations (e.g., Julia code for SplitFFT_lazyEmbed (Siron et al., 2024)) have removed many of the technical barriers to adoption, laying a foundation for continued impact in numerical linear algebra, computational physics, real-time analytics, and domain-specific hardware acceleration.