Michael Brenndoerfer | Data & AI, Private Equity, Technology

Michael Brenndoerfer

Finite Difference Methods for Option Pricing › Convergence Analysis and Method Comparison

Michael BrenndoerferDecember 4, 20253 min read

Quantitative FinanceAll chapters

Part 6 of 15Numerical Methods for Derivative Pricing

Chapter 36Finite Difference Methods for Option Pricing › Convergence Analysis and Method Comparison

Reading section 7 of 14 · Convergence Analysis and Method Comparison · 3 minSection 7 of 14 · 3 min

Section 7 of 14 · 3 min read

Finite Difference Methods for Option Pricing › Convergence Analysis and Method ComparisonOne section · Sections in this chapter7 / 14 ↓

Sections in this chapter14

Reading tools Definitions & inline links

Choose your expertise level to adjust how many terms are explained. Beginners see more tooltips, experts see fewer to maintain reading flow. Hover over underlined terms for instant definitions.

Article links

Make inline references clickable

Now let's compare all three finite difference methods against the analytical Black-Scholes formula to assess their accuracy and convergence properties.

In[21]:

Code

from scipy.stats import norm


def black_scholes_call(S, K, T, r, sigma):
    """Analytical Black-Scholes call price."""
    d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    return S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)


# Analytical price
bs_price = black_scholes_call(S_0, K, T, r, sigma)

Out[22]:

Console

Black-Scholes analytical price: $10.450584

Finite difference prices:
  Explicit (N=5000):        $10.440896  Error: $0.009688
  Implicit (N=500):         $10.438580  Error: $0.012004
  Crank-Nicolson (N=500):   $10.440686  Error: $0.009897

All three methods converge to the analytical Black-Scholes price. The Crank-Nicolson scheme achieves an error comparable to the implicit scheme in this snapshot, but with better theoretical convergence properties that become apparent on finer grids.

Convergence StudyLink Copied

Let's examine how the error decreases as we refine the grid. This reveals the order of convergence for each method.

In[23]:

Code

# Convergence study
M_values = [50, 100, 200, 400]
errors_cn = []
errors_implicit = []

for m_sim in M_values:
    n_sim = 10 * m_sim  # Keep ratio fixed

    # Crank-Nicolson
    S_grid, V = crank_nicolson_european_call(
        S_max, K, T, r, sigma, m_sim, n_sim
    )
    idx = np.argmin(np.abs(S_grid - S_0))
    errors_cn.append(abs(V[idx] - bs_price))

    # Implicit
    S_grid, V = implicit_european_call(S_max, K, T, r, sigma, m_sim, n_sim)
    idx = np.argmin(np.abs(S_grid - S_0))
    errors_implicit.append(abs(V[idx] - bs_price))

Out[24]:

Visualization

Log-log line chart showing decreasing absolute pricing error for implicit and Crank-Nicolson schemes as the number of price steps rises from 50 to 400. — Empirical grid-refinement errors for the implicit and Crank-Nicolson schemes. Both errors decrease as the price grid is refined, with Crank-Nicolson producing the smaller error at each tested resolution. Because the experiment refines space and time together, the slopes reflect their combined discretization error rather than an isolated theoretical order.

The convergence plot shows that both methods become more accurate as the coupled price and time grids are refined. Crank-Nicolson produces the smaller error at every tested resolution. Since this experiment changes $ΔS$ and $Δt$ together, its slope combines spatial and temporal effects; isolating a formal convergence order would require holding one discretization error negligible while varying the other.