Finite Difference Methods for Option Pricing › Comparing Methods
Quantitative FinanceAll chapters Finite Difference Methods for Option Pricing › Comparing MethodsOne section · Sections in this chapter9 / 14 ↓
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
Let's bring together all the numerical methods we've covered for pricing options: binomial trees, Monte Carlo simulation, and finite difference methods.
def binomial_european_call(S, K, T, r, sigma, N):
"""Price European call using binomial tree."""
dt = T / N
u = np.exp(sigma * np.sqrt(dt))
d = 1 / u
p = (np.exp(r * dt) - d) / (u - d)
# Terminal payoffs
payoffs = np.array(
[max(S * u**j * d ** (N - j) - K, 0) for j in range(N + 1)]
)
# Backward induction
for i in range(N - 1, -1, -1):
payoffs = np.exp(-r * dt) * (
p * payoffs[1 : i + 2] + (1 - p) * payoffs[0 : i + 1]
)
return payoffs[0]
def monte_carlo_european_call(S, K, T, r, sigma, n_paths=100000, seed=42):
"""Price European call using Monte Carlo simulation."""
np.random.seed(seed)
Z = np.random.standard_normal(n_paths)
S_T = S * np.exp((r - 0.5 * sigma**2) * T + sigma * np.sqrt(T) * Z)
payoffs = np.maximum(S_T - K, 0)
return np.exp(-r * T) * payoffs.mean()# Compute prices using all methods
S = S_0 # Use scalar spot price for comparison
price_bs = black_scholes_call(S, K, T, r, sigma)
price_binomial = binomial_european_call(S, K, T, r, sigma, N=500)
price_mc = monte_carlo_european_call(S, K, T, r, sigma)
# Finite difference prices already computed
S_grid, V_cn_final = crank_nicolson_european_call(
S_max, K, T, r, sigma, M, N=500
)
idx = np.argmin(np.abs(S_grid - S))
price_fd = V_cn_final[idx]European Call Option Price Comparison ================================================== Parameters: S=100, K=100.0, T=1.0, r=0.05, σ=0.2 ================================================== Method Price Error -------------------------------------------------- Black-Scholes (exact) $ 10.4506 - Binomial Tree (N=500) $ 10.4466 $ 0.003998 Monte Carlo (100K paths) $ 10.4739 $ 0.023308 Crank-Nicolson FD $ 10.4407 $ 0.009897
The Finite Difference (Crank-Nicolson) method matches the exact Black-Scholes price with high precision, comparable to the Binomial Tree. Unlike Monte Carlo, which shows stochastic variation, the finite difference result is deterministic and stable for this 1D problem.
Method Characteristics
Each numerical method has distinct strengths and weaknesses:
Binomial Trees:
- Intuitive, based on discrete price movements
- Natural for American options with early exercise
- Accuracy limited by number of time steps
- Convergence can be non-monotonic
- Excellent for path-dependent options
- Easily handles multiple underlying assets (high dimensions)
- Statistical error decreases slowly ()
- Less natural for American options (though methods like Longstaff-Schwartz exist)
Finite Difference Methods:
- Directly solves the pricing PDE
- Very efficient for one or two underlying assets
- Natural for American options and barrier options
- Difficulty increases rapidly with dimension
When to Use Each Method
The choice of numerical method depends on the specific option being priced:
- European options on single assets: All methods work well; analytical formulas (when available) are fastest
- American options: Finite difference methods and binomial trees are natural choices
- Barrier options: Finite difference methods handle absorbing boundaries elegantly
- Path-dependent options (Asian, lookback): Monte Carlo is typically preferred
- Multi-asset options: Monte Carlo scales better to high dimensions
We'll explore exotic options and their pricing in the next chapter, where we'll see how these numerical methods adapt to more complex payoff structures.