衍生品定价与希腊字母

V₀ = e^(−rT) · E^Q[Payoff(S_T)]

关键：期望是在风险中性测度 Q 下取的，标的漂移率为 r（不是真实收益 μ）

C = S·N(d₁) − K·e^(−rT)·N(d₂)

d₁ = [ln(S/K) + (r + σ²/2)T] / (σ√T)
d₂ = d₁ − σ√T

N(·)：标准正态累积分布函数

import numpy as np
from scipy.stats import norm

def bs_call(S, K, T, r, sigma):
    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)

print(f"{bs_call(100, 100, 1.0, 0.03, 0.20):.4f}")   # 平价看涨，约 9.41

C − P = S − K·e^(−rT)

CRR 参数：u = e^(σ√Δt),  d = 1/u,  p = (e^(rΔt) − d) / (u − d)

import numpy as np

def binomial_american(S, K, T, r, sigma, N=500, is_call=True):
    dt = T / N
    u = np.exp(sigma * np.sqrt(dt))
    d = 1 / u
    p = (np.exp(r * dt) - d) / (u - d)
    disc = np.exp(-r * dt)
    # 到期日各节点价格
    j = np.arange(N + 1)
    ST = S * u ** (2 * j - N)
    V = np.maximum(ST - K, 0) if is_call else np.maximum(K - ST, 0)
    # 逆向归纳：每步比较「继续持有」与「立即行权」
    for i in range(N - 1, -1, -1):
        j = np.arange(i + 1)
        Si = S * u ** (2 * j - i)
        cont = disc * (p * V[1:i+2] + (1 - p) * V[0:i+1])
        exercise = np.maximum(Si - K, 0) if is_call else np.maximum(K - Si, 0)
        V = np.maximum(cont, exercise)      # 美式：可取行权价值
    return V[0]

def mc_european_call(S, K, T, r, sigma, n_paths=100_000, steps=252):
    dt = T / steps
    z = np.random.standard_normal((n_paths, steps))
    # 对数价格的对数增量，避免直接模拟价格（更稳定）
    log_incr = (r - 0.5 * sigma ** 2) * dt + sigma * np.sqrt(dt) * z
    ST = S * np.exp(log_incr.sum(axis=1))          # 到期价格
    payoff = np.maximum(ST - K, 0)
    return np.exp(-r * T) * payoff.mean(), payoff.std() / np.sqrt(n_paths)  # 价格与标准误

def mc_antithetic(S, K, T, r, sigma, n_paths=50_000, steps=252):
    dt = T / steps
    z = np.random.standard_normal((n_paths // 2, steps))
    incr = (r - 0.5 * sigma ** 2) * dt + sigma * np.sqrt(dt) * z
    ST_pos = S * np.exp(incr.sum(axis=1))
    ST_neg = S * np.exp((-z * sigma * np.sqrt(dt) + (r - 0.5 * sigma ** 2) * dt).sum(axis=1))
    payoff = (np.maximum(ST_pos - K, 0) + np.maximum(ST_neg - K, 0)) / 2
    return np.exp(-r * T) * payoff.mean()

def implied_vol(price, S, K, T, r, tol=1e-6, max_iter=100):
    sigma = 0.2                                   # 初始猜测
    for _ in range(max_iter):
        diff = bs_call(S, K, T, r, sigma) - price
        if abs(diff) < tol:
            break
        vega = S * norm.pdf(d1_of(S, K, T, r, sigma)) * np.sqrt(T)
        sigma -= diff / vega                      # 牛顿法
    return sigma

隐含波动率
   │  ╲                        ╱
   │   ╲___             ___╱
   │       ╲___________╱
   └──────────────────────────► 行权价 K
     深度虚值卖   平值   深度虚值买

def delta_hedge_simulation(S0, K, T, r, sigma, n_steps=252, rebal=1):
    dt = T / n_steps
    S = S0
    hedge = 0.0
    cost = 0.0
    for i in range(n_steps):
        d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * (T - i * dt)) / (sigma * np.sqrt(T - i * dt))
        target = norm.cdf(d1)                     # 目标 delta 持仓
        trade = target - hedge
        cost += abs(trade) * S * 0.0002           # 假设 2 bp 交易成本
        hedge = target
        S *= np.exp((r - 0.5 * sigma ** 2) * dt + sigma * np.sqrt(dt) * np.random.standard_normal())
    return cost

def barrier_knockout_call(S, K, B, T, r, sigma, n_paths=200_000, steps=252):
    # 向上敲出看涨：路径触及障碍 B 则作废
    dt = T / steps
    z = np.random.standard_normal((n_paths, steps))
    log_paths = np.cumsum((r - 0.5 * sigma ** 2) * dt + sigma * np.sqrt(dt) * z, axis=1)
    ST = S * np.exp(log_paths[:, -1])
    max_path = S * np.exp(log_paths.max(axis=1))       # 路径最大值
    alive = max_path < B                               # 未触及障碍
    return np.exp(-r * T) * np.maximum(ST - K, 0)[alive].mean()

行情 → 曲面校准 → 定价引擎 → 希腊字母 → 风控/交易
         ↑
    校准缓存（按标的+到期缓存，避免重复计算）