FFT & Transforms (vDSP)

AppleAccelerate wraps Apple's vDSP transform functions for FFT, real FFT, DFT, and DCT.

FFT

The FFT API wraps Apple's vDSP FFT functions and follows the same naming conventions as AbstractFFTs.jl. Both 1D vectors and 2D matrices are supported with ComplexF64 and ComplexF32 inputs. A 1D fft/ifft/bfft/rfft/irfft (called without an explicit plan_fft setup) accepts any power-of-two length, plus non-power-of-two lengths of the form f * 2^k with f ∈ {3, 5, 15} — for complex transforms k ≥ 3 (so the smallest such lengths are 24, 40, 120), and for real transforms k ≥ 4. Powers of two use vDSP's fast FFT path, while the mixed-radix lengths transparently use Apple's DFT (see is_supported_fft_length). 2D transforms remain power-of-2 only. Unsupported lengths throw an ArgumentError.

Choosing between AppleAccelerate and FFTW

AppleAccelerate's FFT is a direct vDSP binding: 1-D transforms support powers of two plus f * 2^k lengths (f ∈ {3, 5, 15}, with k ≥ 3 for complex and k ≥ 4 for real transforms), while 2-D transforms are power-of-2 only. Only 1-D vectors and 2-D matrices are supported, and it is reached exclusively through the AppleAccelerate. prefix. It does not plug into the AbstractFFTs.jl interface — loading AppleAccelerate never changes what fft/plan_fft do in your session, and will never override FFTW.jl.

For general sizes, 3-D and higher arrays, dimension-selective (region) transforms, or the standard Julia FFT interface, use FFTW.jl. vDSP is mainly competitive at small transform sizes; FFTW is typically faster at larger ones.

Real FFT (rfft, irfft, brfft) is likewise available only through the AppleAccelerate. prefix.

x = randn(ComplexF64, 1024)

# Forward FFT (auto-creates plan)
X = AppleAccelerate.fft(x)

# Normalized inverse FFT
x_recovered = AppleAccelerate.ifft(X)

# Unnormalized inverse (backward) FFT
X_back = AppleAccelerate.bfft(X)

# Reusable plan for repeated transforms of the same size
setup = AppleAccelerate.plan_fft(x)
X = AppleAccelerate.fft(x, setup)
x_recovered = AppleAccelerate.ifft(X, setup)

2D FFT works the same way — fft dispatches on the input shape:

x2 = randn(ComplexF64, 16, 32)
X2 = AppleAccelerate.fft(x2)
x2_recovered = AppleAccelerate.ifft(X2)

Batched 1D FFT

Passing a dims argument (1 = each column, 2 = each row) computes a batch of independent 1D transforms over a matrix in a single call, like FFTW's fft(A, dims). This wraps vDSP_fftm_zop. The transform length (size(A, dims)) must be a power of 2:

A = randn(ComplexF64, 16, 8)
F = AppleAccelerate.fft(A, 1)     # FFT of each column
A1 = AppleAccelerate.ifft(F, 1)   # normalized inverse
@assert A1 ≈ A

In-place FFT

In-place variants avoid allocating the output array:

x = randn(ComplexF64, 1024)
y = copy(x)
AppleAccelerate.fft!(y)       # forward, modifies y in-place
AppleAccelerate.ifft!(y)      # inverse, modifies y in-place
@assert y ≈ x

Temp-buffer variants

For repeated transforms of the same size, an FFTWorkspace supplies vDSP with a reusable scratch buffer (the *t vDSP variants), avoiding its internal per-call allocation. Pass it as the last argument to fft/fft!/bfft/ifft (1D, 2D, or batched) and to the real transforms. Results are identical to the non-workspace calls.

x = randn(ComplexF64, 1024)
setup = AppleAccelerate.plan_fft(x)
ws = AppleAccelerate.FFTWorkspace(x)
X = AppleAccelerate.fft(x, setup, ws)
@assert AppleAccelerate.ifft(X, setup, ws) ≈ x

AppleAccelerate.plan_fft — Function

plan_fft(x::VecOrMat{Complex{T}}) where T <: Union{Float32, Float64}
plan_fft(n::Integer, [T=Float64], [radix=2])

Create a reusable FFT setup object for repeated transforms of the same size. Wraps vDSP_create_fftsetup / vDSP_create_fftsetupD. The setup is automatically destroyed when garbage collected.

Function	Description
`plan_dct`	Create a DCT setup object
`dct`	Compute the Discrete Cosine Transform
`idct`	Compute the inverse Discrete Cosine Transform
`plan_destroy`	Destroy a DCT setup object