Finite Difference Methods Overview
Finite Difference Methods Overview
Finite difference methods solve the Black-Scholes PDE on a discrete grid—a mesh net of spot prices and time points. By replacing continuous derivatives with discrete approximations, these methods price options through backward induction from terminal conditions. Understanding scheme selection and stability is essential for reliable implementation.
Grid Setup and Notation
The Black-Scholes PDE:
∂V/∂t + ½σ²S²(∂²V/∂S²) + rS(∂V/∂S) - rV = 0
Discretization:
- S-axis: S_j = jΔS for j = 0, 1, ..., M (spot grid)
- t-axis: t_n = nΔt for n = 0, 1, ..., N (time grid)
- V_j^n = V(S_j, t_n) is the option value at grid point
Grid parameters:
- ΔS = S_max / M (spot step size)
- Δt = T / N (time step size)
- M = 200 typical (spot grid points)
- N = 100 typical (time steps)
Example grid:
- S_max = 300 (for ATM at 100)
- M = 200 → ΔS = 1.50
- T = 0.25 years
- N = 100 → Δt = 0.0025 years
Scheme Comparison
Explicit Scheme
Calculates V_j^n from V_j^(n+1) directly:
V_j^n = p_u × V_(j+1)^(n+1) + p_m × V_j^(n+1) + p_d × V_(j-1)^(n+1)
Where coefficients depend on σ, r, ΔS, Δt.
Pros: Simple to implement, no matrix inversion Cons: Stability requires small time steps
Implicit Scheme
Solves a system of equations at each time step:
A × V^n = V^(n+1)
Where A is a tridiagonal matrix.
Pros: Unconditionally stable Cons: Requires solving linear system each step
Crank-Nicolson Scheme
Averages explicit and implicit approaches:
½(A_explicit × V^n + A_implicit × V^n) = ½(V^(n+1) + boundary terms)
Pros: Second-order accuracy in time, stable Cons: More complex implementation
| Scheme | Time Accuracy | Stability Condition | Matrix Solve? |
|---|---|---|---|
| Explicit | O(Δt) | Conditional (CFL) | No |
| Implicit | O(Δt) | Unconditional | Yes |
| Crank-Nicolson | O(Δt²) | Unconditional | Yes |
Stability and the CFL Condition
The explicit scheme requires the CFL (Courant-Friedrichs-Lewy) condition:
ν = σ²Δt / ΔS² ≤ 0.5
Example stability check:
- σ = 30% = 0.30
- ΔS = 1.50
- Δt = 0.0025
ν = (0.30)² × 0.0025 / (1.50)² = 0.0001 / 2.25 = 0.0001
Since 0.0001 << 0.5, the explicit scheme is stable with these parameters.
Failure example:
- σ = 80% = 0.80
- ΔS = 1.00
- Δt = 0.01
ν = (0.80)² × 0.01 / (1.00)² = 0.0064
Still under 0.5, but high volatility requires attention. If we increase Δt to 0.1:
ν = (0.80)² × 0.1 / (1.00)² = 0.064
Still stable, but approaching limits. For very high vol or coarse grids, implicit or Crank-Nicolson is safer.
Stability Tips
- Always verify CFL: Before running explicit scheme, compute ν and confirm ν ≤ 0.5
- Refine grid for high vol: When σ > 50%, reduce Δt or increase ΔS
- Use implicit for exotics: Barrier options near barrier require stability
- Test convergence: Compare results with 2× and 4× grid refinement; prices should converge
Boundary Conditions
At S = 0:
- Call: V(0, t) = 0 (worthless if stock at zero)
- Put: V(0, t) = Ke^(-r(T-t)) (intrinsic value)
At S = S_max:
- Call: V(S_max, t) ≈ S_max - Ke^(-r(T-t)) (deep ITM)
- Put: V(S_max, t) = 0 (worthless if stock very high)
Terminal condition (at t = T):
- Call: V(S, T) = max(S - K, 0)
- Put: V(S, T) = max(K - S, 0)
Set S_max sufficiently large (3-4× spot) so boundary has minimal impact on ATM prices.
Implementation Example
Crank-Nicolson for European call:
Grid:
- S_max = 300, M = 200, ΔS = 1.50
- T = 0.25, N = 100, Δt = 0.0025
- σ = 30%, r = 5%, K = 100
Algorithm:
- Initialize V^N with terminal payoff: V_j^N = max(jΔS - K, 0)
- For n = N-1 down to 0:
- Set up tridiagonal system
- Apply boundary conditions
- Solve system for V^n
- Interpolate V at S = 100 (or nearest grid point)
Result: Call price ≈ $7.14 (matches Black-Scholes)
Grid sensitivity:
| Grid (M × N) | Call Price | Error vs. BS |
|---|---|---|
| 50 × 25 | $7.18 | +0.04 |
| 100 × 50 | $7.15 | +0.01 |
| 200 × 100 | $7.14 | <0.01 |
| 400 × 200 | $7.14 | <0.01 |
200 × 100 provides sub-cent accuracy for vanilla options.
American Options and Early Exercise
For American options, at each time step:
V_j^n = max(V_j^n_continuation, intrinsic_j)
Where intrinsic_j = max(K - jΔS, 0) for put or max(jΔS - K, 0) for call.
This free boundary problem is naturally handled by finite differences through this comparison at each node.
Runtime Considerations
| Grid Size | Explicit Runtime | Crank-Nicolson Runtime |
|---|---|---|
| 100 × 50 | 1 ms | 2 ms |
| 200 × 100 | 4 ms | 8 ms |
| 500 × 250 | 25 ms | 50 ms |
Finite differences are efficient for single-asset problems. For multi-asset options, dimensionality makes Monte Carlo preferable.
The stability of finite difference methods depends critically on the relationship between Δt and ΔS. When refining the grid, always verify that the CFL condition remains satisfied, or switch to an unconditionally stable implicit method. For production systems, Crank-Nicolson offers the best balance of accuracy and stability.
Next Steps
For tree-based alternatives, see Binomial Trees for Option Pricing.
For simulation-based pricing, review Monte Carlo Simulation Techniques.