fft2 — Compute the two-dimensional discrete Fourier transform (DFT) of numeric or complex data.

fft2(X) computes the two-dimensional discrete Fourier transform (DFT) of X. It is equivalent to applying fft along the first dimension and then along the second dimension, preserving MATLAB’s column-major ordering and output shape semantics.

How fft2 works in RunMat

• fft2(X) transforms along the first and second dimensions that have size greater than one.
• fft2(X, M, N) zero-pads or truncates X to M rows and N columns before evaluating the 2-D transform.
• fft2(X, SIZE) accepts a two-element vector (or scalar) specifying the transform lengths.
• Real inputs produce complex outputs; complex inputs are transformed element-wise with no additional conversion.
• Higher-dimensional inputs are transformed slice-by-slice across trailing dimensions, matching MATLAB behaviour.
• Empty dimensions yield empty outputs; zero padding with 0 produces a zero-sized complex tensor.
• GPU arrays execute on-device when the provider advertises the fft_dim hook; otherwise RunMat gathers the data and performs the transform on the host using rustfft.

GPU memory and residency

You usually do NOT need to call gpuArray manually. The fusion planner and native acceleration layer keep tensors on the GPU when a provider offers FFT kernels. If the provider lacks fft_dim, RunMat gathers inputs, evaluates the FFT pair on the host, and returns a MATLAB-compatible complex tensor. You can still use gpuArray for explicit residency control, particularly when interoperating with MATLAB code that expects it.

Examples

Computing the 2-D FFT of a small matrix

X = [1 2; 3 4];
Y = fft2(X)

Expected output:

Y =
    10 + 0i   -2 + 0i
    -4 + 0i    0 + 0i

Zero-padding an image patch before fft2

patch = [1 0 1; 0 1 0; 1 0 1];
F = fft2(patch, 8, 8)

Specifying transform lengths with a size vector

X = rand(4, 6);
F = fft2(X, [8 4]);   % pad rows to 8 and truncate columns to 4

Using fft2 on gpuArray data

G = gpuArray(rand(256, 256));
F = fft2(G);
R = gather(F)

Applying fft2 to each slice of a 3-D volume

V = rand(64, 64, 10);
spectra = fft2(V)

Verifying fft2 against sequential fft calls

X = rand(5, 7);
sequential = fft(fft(X, [], 1), [], 2);
direct = fft2(X)

FAQ

Is fft2(X) the same as fft(fft(X, [], 1), [], 2)?

Yes. RunMat literally performs the two sequential transforms so the results match MATLAB exactly.

How do zero-length transform sizes behave?

Passing 0 for either M or N produces a complex tensor with zero elements along that dimension.

Can I use a single scalar for the size argument?

Yes. fft2(X, K) is shorthand for fft2(X, [K K]), padding or truncating both dimensions to K.

What happens when X has more than two dimensions?

RunMat applies fft2 to every 2-D slice defined by the first two dimensions, leaving higher dimensions untouched.

Do I get complex outputs for real inputs?

Always. Even when the imaginary parts are zero, outputs are stored as complex tensors to mirror MATLAB semantics.

Will fft2 run on the GPU automatically?

Yes if the active provider implements fft_dim. Otherwise RunMat gathers to the host and performs the transform with rustfft.

Does fft2 normalise the output?

No. Like MATLAB, the forward FFT leaves scaling untouched; use ifft2 for the inverse with 1/(M*N) scaling.

Can I mix [] with explicit sizes (e.g., fft2(X, [], 128))?

Yes. Passing [] leaves that dimension unchanged while applying the specified size to the other dimension.

Related functions to explore

These functions work well alongside fft2. Each page has runnable examples you can try in the browser.

fft, ifft, fftshift, gpuArray, gather, ifft2, ifftshift

Open-source implementation

Unlike proprietary runtimes, every RunMat function is open-source. Read exactly how fft2 works, line by line, in Rust.

• View fft2.rs on GitHub
• Learn how the runtime works
• Found a bug? Open an issue with a minimal reproduction.

About RunMat

RunMat is an open-source runtime that executes MATLAB-syntax code — faster, on any GPU, with no license required.

• Simulations that took hours now take minutes. RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed.
• Start running code in seconds. Open the browser sandbox or download a single binary. No license server, no IT ticket, no setup.
• A full development environment. GPU-accelerated 2D and 3D plotting, automatic versioning on every save, and a browser IDE you can share with a link.

Getting started · Benchmarks · Pricing