Computational Examples¶

Having developed the Black-Scholes formula and its mathematical structure, we now turn to its practical implementation. The mechanism is straightforward — evaluate \(d_1, d_2\), then two CDF values — but the structure of the formula makes the numerical work surprisingly rich: closed-form Greeks fall out by differentiating term by term, vectorised array operations replace contract-by-contract loops, and edge cases (\(T \to 0\), extreme \(d_i\)) require care that the abstract formula hides. This section bridges the formula with practice through hand calculation, a Python implementation, Greeks, sensitivity panels, and worked examples.

Manual Calculation: European Call¶

Section goal: a by-hand evaluation of the call formula at \(S=50\), \(K=52\), \(T=0.5\).

1. Problem Setup¶

Price a European call option with:

• Current stock price: \(S_0 = 50\)
• Strike price: \(K = 52\)
• Time to maturity: \(T = 0.5\) years (6 months)
• Risk-free rate: \(r = 5\%\) per annum
• Volatility: \(\sigma = 30\%\) per annum

2. Compute d_1 and d_2¶

3. Evaluate and Compute¶

From standard normal tables: \(\mathcal{N}(0.0391) = 0.5156\), \(\mathcal{N}(-0.1730) = 0.4313\).

The European call is worth approximately $3.91.

European Put and Parity Check¶

Section goal: pricing the put with the same parameters and verifying \(C - P = S - Ke^{-rT}\).

Using the same parameters and \(\mathcal{N}(-x) = 1 - \mathcal{N}(x)\):

Parity check: \(C - P = 3.91 - 4.62 = -0.71 \approx S_0 - Ke^{-rT} = 50 - 50.72 = -0.72\) ✓

Python Implementation¶

Section goal: a vectorisable black_scholes function for both calls and puts.

1. Basic Implementation¶

```python import numpy as np from scipy.stats import norm

def black_scholes(S, K, T, r, sigma, option_type='call'): """Black-Scholes price for a European call or put.""" d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T)) d2 = d1 - sigma * np.sqrt(T) if option_type == 'call': return S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2) else: return K * np.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)

Example: S0=50, K=52, T=0.5, r=5%, sigma=30%¶

C = black_scholes(50, 52, 0.5, 0.05, 0.30, 'call') # 3.91 P = black_scholes(50, 52, 0.5, 0.05, 0.30, 'put') # 4.62

Verify put-call parity: C - P = S - Ke^(-rT)¶

print(f"C - P = {C - P:.4f}, S - Ke^(-rT) = {50 - 52*np.exp(-0.025):.4f}") ```

Output: C - P = -0.7065, S - Ke^(-rT) = -0.7065

Greeks Calculation¶

Section goal: closed-form delta, gamma, vega, theta, rho — and visual confirmation across spot (Figures 1–2).

1. Complete Implementation with Greeks¶

```python def black_scholes_greeks(S, K, T, r, sigma, option_type='call'): """Black-Scholes price and Greeks; returns dict with price, delta, gamma, theta, vega, rho.""" d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T)) d2 = d1 - sigma * np.sqrt(T) pdf_d1 = norm.pdf(d1) cdf_d1 = norm.cdf(d1) cdf_d2 = norm.cdf(d2)

if option_type == 'call':
    price = S * cdf_d1 - K * np.exp(-r * T) * cdf_d2
    delta = cdf_d1
    theta = (-S * pdf_d1 * sigma / (2 * np.sqrt(T))
             - r * K * np.exp(-r * T) * cdf_d2)
    rho = K * T * np.exp(-r * T) * cdf_d2 / 100
else:  # put
    price = K * np.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)
    delta = cdf_d1 - 1
    theta = (-S * pdf_d1 * sigma / (2 * np.sqrt(T))
             + r * K * np.exp(-r * T) * norm.cdf(-d2))
    rho = -K * T * np.exp(-r * T) * norm.cdf(-d2) / 100

# Gamma and vega (same for call and put; vega quoted per 1% change in sigma)
gamma = pdf_d1 / (S * sigma * np.sqrt(T))
vega = S * np.sqrt(T) * pdf_d1 / 100

return {'price': price, 'delta': delta, 'gamma': gamma,
        'theta': theta, 'vega': vega, 'rho': rho}

```

For the same parameters (\(S=50\), \(K=52\), \(T=0.5\), \(r=5\%\), \(\sigma=30\%\)):

Note that gamma and vega are identical for call and put (a consequence of put-call parity), while \(\Delta_{\text{call}} - \Delta_{\text{put}} = 1\).

Sensitivity Analysis¶

Section goal: how the price responds to changes in \(\sigma\), \(S\), and \(T\).

Both call and put prices are monotonically increasing in volatility (positive vega) and respond nonlinearly to the stock price. The call value curve lies above the intrinsic value \((S - K)^+\) for all \(S\), with the gap (time value) maximized near the strike. These relationships can be verified numerically using the black_scholes function above across ranges of \(\sigma\) and \(S\).

Practical Examples¶

Section goal: three numerical illustrations: maturity scaling, moneyness vs. delta, and implied volatility (Figure 3).

1. ATM Call with Different Maturities¶

For \(S = K = 100\), \(r = 5\%\), \(\sigma = 25\%\):

What we learn: Option value grows sublinearly with time—roughly as \(\sqrt{T}\), consistent with the ATM approximation \(C_{\text{ATM}} \approx 0.4\, S\sigma\sqrt{T}\). This \(\sqrt{T}\) scaling is a direct consequence of the diffusive nature of Brownian motion.

2. Moneyness and Delta¶

For \(S = 100\), \(r = 5\%\), \(\sigma = 25\%\), \(T = 0.5\):

What we learn: Delta varies from near \(0\) (deep OTM) to near \(1\) (deep ITM), confirming the probabilistic interpretation \(\Delta = \mathcal{N}(d_1)\). ITM options carry substantial intrinsic value; OTM options derive their entire value from optionality.

3. Example 3: Implied Volatility Calculation¶

Given a market option price, back out the implied volatility:

```python from scipy.optimize import brentq

def black_scholes_call(S, K, T, r, sigma): """Convenience wrapper: Black-Scholes price for a European call.""" return black_scholes(S, K, T, r, sigma, option_type='call')

def implied_volatility_call(market_price, S, K, T, r): """ Calculate implied volatility for a call option. Uses Brent's method to find sigma such that BS price = market price. Brent works here because the BS call price is strictly increasing in sigma (positive vega), which guarantees a unique root in any bracket [sigma_lo, sigma_hi] containing it. Brent combines bisection (for robustness) with inverse quadratic interpolation (for superlinear convergence near the root); typical convergence is ~5–10 iterations. Conditioning degrades when vega is small — i.e., for deep ITM/OTM or near-expiry options — so very-low-time-value quotes can yield wide confidence on sigma despite the algorithm reporting tight tolerance. """ def objective(sigma): return black_scholes_call(S, K, T, r, sigma) - market_price

try:
    # Search for volatility between 1% and 200%
    implied_vol = brentq(objective, 0.01, 2.0)
    return implied_vol
except ValueError:
    return np.nan

Example: market call price is $6.00¶

market_call_price = 6.00 S, K, T, r = 100, 100, 0.5, 0.05

implied_vol = implied_volatility_call(market_call_price, S, K, T, r) print(f"Market Call Price: ${market_call_price}") print(f"Implied Volatility: {implied_vol * 100:.2f}%")

Verify¶

bs_price = black_scholes_call(S, K, T, r, implied_vol) print(f"BS Price at Implied Vol: ${bs_price:.2f}") ```

Output: Market Call Price: $6.00 Implied Volatility: 30.55% BS Price at Implied Vol: $6.00

Common Numerical Issues¶

Section goal: edge cases (extreme \(d\), \(T \to 0\), low \(\sigma\)) and how to handle them.

1. Issue 1: Extreme Values of d_1 or d_2¶

When \(d_1\) or \(d_2\) are very large (positive or negative), numerical precision issues arise in evaluating \(\mathcal{N}(d)\).

Solution: Use asymptotic approximations:

• If \(d_1 > 8\): \(\mathcal{N}(d_1) \approx 1\)
• If \(d_1 < -8\): \(\mathcal{N}(d_1) \approx 0\)

2. Issue 2: Near Expiration (T → 0)¶

As \(T \to 0\), \(d_1\) and \(d_2\) can become undefined (division by zero).

Solution: For \(T < 0.001\), use intrinsic value directly:

3. Issue 3: Very Low Volatility (σ → 0)¶

When \(\sigma\) is very small, option behaves like forward contract.

Solution: Use forward value formula:

4. Issue 4: Vectorized Pricing and Greeks¶

For large-scale pricing (e.g., computing prices and Greeks across a grid of strikes and maturities), evaluate \(d_1\), \(d_2\), \(\mathcal{N}(\cdot)\), and \(\phi(\cdot)\) as array operations rather than looping over individual contracts. The functions defined above are already vectorized: passing NumPy arrays for S, K, T, or sigma makes np.log, np.sqrt, np.exp, norm.cdf, and norm.pdf broadcast automatically, so a single call computes the entire grid. The Greeks dictionary returned by black_scholes_greeks then contains arrays of the same shape — typically a \(10^4\!-\!10^6\times\) speedup over Python-level loops, and the bottleneck for production risk systems with millions of contracts. (The same broadcasting principle applies to implied-volatility surfaces: vectorize the objective inside Brent only if you also vectorize the bracketing logic, since brentq itself is scalar.)

Complete Working Example¶

Section goal: an end-to-end pricing of a representative OTM call with full Greeks.

Consider a call option with \(S = \$175\), \(K = \$180\), \(T = 45/365\) years, \(r = 4.5\%\), \(\sigma = 28\%\).

Using the Greeks function above, the results are:

What we learn: This OTM call is worth $3.67, consisting entirely of time value. The delta of \(0.41\) means the option captures roughly 41 cents of each dollar move in the stock—far less than a stock position, but with a much smaller capital outlay ($3.67 vs. $175). The high gamma (\(0.044\)) indicates that delta itself changes rapidly near the strike, which is characteristic of short-dated, near-ATM options. The negative theta of $0.06 per day reflects the time decay that erodes the option's value as expiration approaches.

Summary¶

The examples above illustrate three key computational takeaways:

1. The standard normal CDF \(\mathcal{N}(\cdot)\) is the only special function required—Black-Scholes pricing reduces to evaluating two CDF values
2. Greeks provide first-order sensitivity measures that connect the formula's mathematical structure to hedging practice
3. Put-call parity and the ATM \(\sqrt{T}\) scaling serve as quick sanity checks for any implementation

Exercises¶

Exercise 1. Price a European put option with \(S_0 = 65\), \(K = 60\), \(T = 0.75\) years, \(r = 3\%\), and \(\sigma = 35\%\). Show every intermediate step: compute \(d_1\), \(d_2\), \(\mathcal{N}(-d_1)\), \(\mathcal{N}(-d_2)\), and the final put price. Verify your answer using put-call parity.

Exercise 2. A market maker observes a European call on a non-dividend-paying stock trading at $8.25. The stock price is \(S_0 = 110\), the strike is \(K = 105\), the risk-free rate is \(r = 4\%\), and the option expires in 90 days. Using the bisection method (or Brent's method), find the implied volatility to four decimal places. Describe the convergence behavior of your root-finding algorithm.

Exercise 3. Compute the full set of Greeks (delta, gamma, vega, theta, rho) for a European call with \(S_0 = 100\), \(K = 100\), \(T = 1\), \(r = 5\%\), and \(\sigma = 20\%\). Then verify the following relationships numerically:

Exercise 4. Using the Black-Scholes formula, create a table of call option prices for \(S_0 = 100\), \(r = 5\%\), \(\sigma = 25\%\), with strikes \(K \in \{80, 90, 100, 110, 120\}\) and maturities \(T \in \{0.25, 0.5, 1.0, 2.0\}\) years. For each entry, decompose the price into intrinsic value and time value. Identify which combination of strike and maturity has the largest time value, and explain why.

Exercise 5. Implement a finite-difference approximation to verify the Black-Scholes Greeks. For the call with parameters \(S_0 = 50\), \(K = 52\), \(T = 0.5\), \(r = 5\%\), \(\sigma = 30\%\), compute:

with \(h = 0.01\). Compare with the analytical Greeks and report the relative errors.

Exercise 6. A trader holds a portfolio of three European options on the same underlying (\(S_0 = 100\), \(r = 5\%\), \(\sigma = 20\%\)): long 10 calls with \(K = 95\) and \(T = 0.5\), short 20 calls with \(K = 100\) and \(T = 0.5\), and long 10 calls with \(K = 105\) and \(T = 0.5\). Compute the portfolio's total delta, gamma, and vega. Identify this position as a well-known option strategy and explain its payoff profile at expiration.