Overview

fftw wraps FFTW3 — the fastest available FFT library, used in NumPy, SciPy, MATLAB, and scientific computing worldwide. It computes Discrete Fourier Transforms in O(N log N) and self-optimizes at runtime for your specific hardware (FFTW "plans").

1-D FFT — Frequency Analysis

uses fftw;

const SampleRate = 44100;
const N = 4096;

// Generate test signal: 440 Hz + 1000 Hz sine waves
var signal: array of Double;
SetLength(signal, N);
for I := 0 to N-1 do
  signal[I] := Sin(2*Pi*440*I/SampleRate) + 0.5*Sin(2*Pi*1000*I/SampleRate);

// Apply Hann window to reduce spectral leakage
var windowed := WindowHann(signal);

// Forward FFT — get complex spectrum
var spectrum := FFT(windowed);

// Power spectrum (magnitude squared per bin)
var power := PowerSpectrum(windowed);

// Find dominant frequency
var peakK := PeakBin(power);
WriteLn('Peak frequency: ', FrequencyBin(peakK, SampleRate, N):0:1, ' Hz');

// Full frequency axis
var freqs := FrequencyAxis(SampleRate, N);
WriteLn('Bin 10 = ', freqs[10]:0:2, ' Hz');

Inverse FFT

// Round-trip: signal → FFT → IFFT → signal
var spectrum := FFT(signal);
var restored := IFFT(spectrum, Length(signal));

// Complex FFT (full complex input)
var cspec := FFTComplex(complexSignal);
var back  := IFFTComplex(cspec);

2-D FFT — Image / Matrix

// 2-D FFT on a 512×512 matrix (e.g. image processing)
var spectrum2d := FFT2D(imageData, 512, 512);
var filtered   := ApplyFilter(spectrum2d);  // your filter
var restored   := IFFT2D(filtered, 512, 512);

Reusable Plans (high throughput)

// Create plan once for N=4096 — amortizes optimization cost
var plan := PlanFFT(4096);

// Execute many times with same N
for I := 0 to Length(frames) - 1 do begin
  var spec := ExecuteFFT(plan, frames[I]);
  ProcessSpectrum(spec);
end;

DestroyPlan(plan);

// Save optimization results for next run
SaveWisdom('/data/fftw.wisdom');

Window Functions

// Apply before FFT to reduce spectral leakage
var hann     := WindowHann(signal);      // general purpose
var hamming  := WindowHamming(signal);   // similar to Hann
var blackman := WindowBlackman(signal);  // better side-lobe suppression
var flattop  := WindowFlatTop(signal);   // accurate amplitude measurement

Spectrum Helpers

var power := PowerSpectrum(signal);      // |X[k]|^2
var mag   := MagnitudeSpectrum(signal);  // |X[k]|
var phase := PhaseSpectrum(signal);      // angle(X[k]) in radians

// Good FFT sizes are powers of 2
var n := NextPow2(rawLength);  // e.g. 1000 → 1024

// Magnitude of a complex bin
var mag0 := ComplexMag(spectrum[0], spectrum[1]);