Finite Difference Methods Overview

advancedPublished: 2026-01-01

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

SchemeTime AccuracyStability ConditionMatrix Solve?
ExplicitO(Δt)Conditional (CFL)No
ImplicitO(Δt)UnconditionalYes
Crank-NicolsonO(Δt²)UnconditionalYes

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:

  1. Initialize V^N with terminal payoff: V_j^N = max(jΔS - K, 0)
  2. For n = N-1 down to 0:
    • Set up tridiagonal system
    • Apply boundary conditions
    • Solve system for V^n
  3. Interpolate V at S = 100 (or nearest grid point)

Result: Call price ≈ $7.14 (matches Black-Scholes)

Grid sensitivity:

Grid (M × N)Call PriceError 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 SizeExplicit RuntimeCrank-Nicolson Runtime
100 × 501 ms2 ms
200 × 1004 ms8 ms
500 × 25025 ms50 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.

Related Articles