Carr-Madan FFT Pricing

Once a model's characteristic function is known, one option can be priced by numerically integrating over it — but a real desk needs a whole surface, dozens of strikes and expiries at once, and running that integral separately for every single strike is slow. Carr and Madan noticed something better: the option price, as a function of log-strike, is itself (after one adjustment) a Fourier transform of a simple function of the characteristic function. That means the fast Fourier transform (FFT) — an algorithm built to compute exactly this kind of transform, at every output point simultaneously — can produce prices for hundreds of strikes in one pass.

One assembly line instead of one cook per dish

Cooking a hundred dishes one at a time, from scratch, each with its own trip to the pantry, is slow. An assembly line that preps the shared ingredients once and stamps out each dish in parallel is what a commercial kitchen actually does. Pricing every strike with its own separate integral is the one-cook-at-a-time approach; the FFT is the assembly line, computing an entire vector of option prices — one per strike — in a single batched operation, because the FFT algorithm computes many related sums simultaneously far faster than doing each one alone.

$$\psi(v) = \frac{e^{-rT}\,\phi(v - (\alpha+1)i)}{\alpha^2 + \alpha - v^2 + i(2\alpha+1)v}$$

In plain English: $\phi$ is the model's characteristic function, $\alpha>0$ is a damping factor Carr and Madan introduce purely to make the transform well-behaved (raw option prices don't decay fast enough at extreme strikes for the Fourier integral to converge cleanly), and $\psi(v)$ packages the characteristic function into the exact shape a Fourier transform expects. Feed $\psi$ into an FFT, and out comes a whole vector of undiscounted, damped call prices across a grid of log-strikes at once.

Worked example 1: seeing the damping do its job. Without damping, the call price as a function of strike doesn't decay to zero fast enough as the strike goes to zero (deep in the money, the call price approaches $S$, not zero), so its Fourier transform doesn't converge. Multiplying by $e^{\alpha k}$ (where $k$ is log-strike) before transforming forces decay at both ends. A commonly used value is $\alpha=1.5$: at a strike far below spot, $S/K=3$ say, the raw call price is roughly $S-Ke^{-rT}\approx S(1-1/3)=0.67S$ — clearly not shrinking to zero — but $e^{-\alpha k}\times(0.67S)$ with $k=\ln(1/3)=-1.099$ gives $e^{1.5\times1.099}=e^{1.65}=5.20$ times smaller weight applied at that point than at the money, which is enough damping in practice for the transform to converge.

An entire surface like this one is exactly what one FFT-priced strike grid, repeated across expiries, produces — every strike on every tenor slice came from batched Fourier inversions, not thousands of separate numerical integrals.

Worked example 2: the batching, on a toy scale. A real FFT handles $N=4{,}096$ or more grid points at once; to see the mechanics on paper, imagine a toy transform with just $N=4$ points, weights $\psi_0,\psi_1,\psi_2,\psi_3 = 1, 2, 1, 0$ (illustrative numbers standing in for damped, discretised characteristic-function values). The discrete Fourier transform at output index $k$ is $\sum_{j=0}^{3}\psi_j e^{-i2\pi jk/4}$. For $k=0$: $1+2+1+0=4$ (every strike's contribution simply adds, since $e^0=1$). For $k=1$: $1 + 2e^{-i\pi/2} + 1e^{-i\pi} + 0 = 1 - 2i - 1 = -2i$. Two output prices computed from the same four input weights, in one coordinated pass — that's the batching an FFT gives you on however many strikes you configure the grid for, computed together rather than one integral at a time.

What this means in practice

Any model priced through Characteristic Function Pricing — Heston, Variance Gamma, Merton jump-diffusion — uses Carr-Madan or a close variant whenever a full calibration or a full volatility surface is needed, since calibrating a model means repricing dozens of strikes and expiries at every optimiser iteration, and doing that with the FFT rather than strike-by-strike integration is often the difference between a calibration that runs in seconds and one that runs in minutes.