option-pricing

期权定价 — 工具技能

用于回测和分析的期权定价。已实现 5 种方法，全部采用纯 Python + numpy（没有沉重的外部依赖、抽象层或类）。每个函数约 100 行或更少，并接受标量。

目标性能（在此技能中测得）：

• Black-Scholes：0.0012 ms/op（约 800.000 个期权/秒）
• BAW（American 闭式解）：0.0014 ms/op（约 730.000 个期权/秒）
• Binomial N=500：3 ms/op — 比 BS 慢 2000 倍，但精确

每种方法的详细理论，请参阅 references/REFERENCE.md。

---

快速开始

# 1. Black-Scholes (europea)
py scripts/option_pricing.py bs --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20

# 2. Binomial CRR (europea o americana)
py scripts/option_pricing.py binomial --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20 --style american

# 3. Trinomial (europea o americana)
py scripts/option_pricing.py trinomial --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20

# 4. Monte Carlo (europea, antithetic variates)
py scripts/option_pricing.py mc --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20 --paths 200000

# 5. Longstaff-Schwartz (americana via MC)
py scripts/option_pricing.py lsm --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20 \
  --style american --paths 100000 --steps 50

# 6. Barone-Adesi-Whaley (americana closed-form)
py scripts/option_pricing.py bs2 --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20 --q 0.04 \
  --style american

# 7. Greeks analiticos (BS)
py scripts/option_pricing.py greeks --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20

# 8. Implied volatility
py scripts/option_pricing.py iv --S 100 --K 100 --T 0.25 --r 0.05 --price 4.62

# 9. P(ITM) y P(Profit) bajo medida risk-neutral Q
py scripts/option_pricing.py pitm --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20
py scripts/option_pricing.py pitm --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20 --premium 4.62

# 10. Superficie de precios across strikes
py scripts/option_pricing.py surface --S 100 --T 0.25 --r 0.05 --sigma 0.20 \
  --K-min 80 --K-max 120 --K-step 5

# 11. Heston 1993 (vol estocastica, sonrisa via Fourier)
py scripts/option_pricing.py heston --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20 \
  --v0 0.04 --kappa 2.0 --theta 0.04 --sigma_v 0.3 --rho -0.5

# 12. Bates 1996 (Heston + Merton jumps, captura crash risk)
py scripts/option_pricing.py bates --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20 \
  --v0 0.04 --kappa 2.0 --theta 0.04 --sigma_v 0.3 --rho -0.5 \
  --lam 1.0 --mu_J -0.05 --sigma_J 0.10

# 13. Comparar todos los metodos aplicables
py scripts/option_pricing.py all --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20

# Validar contra casos de assets/validation_cases.json
py scripts/option_pricing.py validate

# Benchmark de todos los metodos
py scripts/option_pricing.py bench --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20

---

技能结构

skills/option-pricing/
├── SKILL.md                              # Este archivo (guia rapida)
├── references/
│   └── REFERENCE.md                      # Teoria completa de los 5 metodos
├── assets/
│   ├── defaults.json                     # Parametros default para el CLI
│   └── validation_cases.json             # Casos de test (Hull Examples + extra)
└── scripts/
    └── option_pricing.py                 # CLI con 15 modos + validate + bench

---

CLI 参数（所有模式通用）

Flag	Default	描述
--S	100.0	标的资产的现货价格
--K	100.0	行权价
--T	0.25	距到期时间，单位为年（0.25 = 3 个月）
--r	0.05	无风险利率（连续复利年化）
--q	0.0	连续复利年化股息率
--sigma	0.20	年化波动率
--type	call	call 或 put
--style	european	european 或 american
--steps	500	树的步数 / LSM 的时间步数
--paths	100000	Monte Carlo 路径数
--seed	42	用于确保可复现性的 Seed
--antithetic	True	启用反变量（MC）
--json	False	输出为 JSON，而非表格

默认值从 assets/defaults.json 加载（可修改）。

---

9 种方法 + 基准测试（在 Python 3.14 + numpy 2.4.4 中测得）

基准测试输入（ATM call，所有方法使用相同数值）： S=100, K=100, T=0.25, r=0.05, q=0, sigma=0.20。使用 2000 次重复测量（慢速方法使用更少次数），运行于 Windows 11。并非估算值——使用 time.perf_counter() 对技能暴露的函数进行实测。

方法	时间复杂度	us/op（实测）	ops/sec	风格	典型误差
Black-Scholes bs	O(1)	2.4 us	419k/s	European	0（闭式解）
P(ITM) pitm	O(1)	1.1 us	908k/s	两者	0（闭式 N(d2)）
Greeks (BS) greeks	O(1)	3.9 us	257k/s	European	0（闭式解）
BS2/BAW bs2	O(1)	3.6 us	276k/s	American	与 binomial N=2000 相比 <1%
IV 求解 iv	O(log(1/eps) * 1 个期权)	82 us	12k/s	两者	1e-7
Heston heston	O(N_GL) ~ O(1)	398 us	2.5k/s	European	<0.1%
Binomial N=500 binomial --steps 500	O(N^2)	5.6 ms	178/s	两者	~0.5%
Bates bates（15 项）	O(15 * N_GL)	6.2 ms	160/s	European	<0.5%
MC paths=10k mc --paths 10000	O(paths)	1.3 ms	788/s	European	~1%（stderr）
Trinomial N=500 trinomial --steps 500	O(N^2)	9.4 ms	107/s	两者	~0.3%
MC paths=100k mc --paths 100000	O(paths)	5.6 ms	177/s	European	~0.1%（stderr）
Binomial N=2000 binomial --steps 2000	O(N^2)	31 ms	32/s	两者	~0.1%
LSM paths=10k lsm	O(paths * steps)	~150 ms	~7/s	American	~1-2%

如何解读此表

• us/op = 每个期权的微秒数（越低 = 越快）
• ops/sec = 每秒可执行的操作数，用于回测
• 对于大规模回测（每次运行 >10k 个期权）：使用 bs、bs2、heston（全部 >2.5k/s）
• 对于与已知值进行验证：使用 binomial --steps 2000（误差 0.1%）
• 对于波动率微笑/校准：使用 heston（约 400 us，O(1)）
• 对于含崩盘的压力测试：使用 bates（约 6 ms，使用截断级数时为 O(1)）
• 对于大规模美式期权：使用 bs2（3.6 us）——不要使用 binomial（5.6 ms）或 lsm（150 ms）

时间复杂度概述

• O(1) 闭式解：BS、BS2/BAW、Heston（Fourier）、P(ITM)、Greeks、IV
• O(N^2) 树：二叉树 CRR、三叉树 Boyle
• O(paths)：MC、MC 对偶变量
• O(paths * steps)：LSM、使用 paths 的 MCS
• O(15) 级数：Bates（15 项 Heston 级数）

回测规则：3 种闭式解（BS、BS2、Heston）合计可运行 约 300k ops/sec。处理 1M 个期权约需 3 秒。足以对 1-2 周的历史数据进行回测，涵盖多个行权价/到期日。

---

5 种方法（旧版）

行业标准。无法处理美式期权。

适用场景：任何欧式期权。大规模回测（每天 1M+ 个期权）。解析 Greeks（直接扩展）。

2. 二叉树 Cox-Ross-Rubinstein（binomial）

离散树。支持欧式和美式期权，并支持提前行权。 O(N^2)，N=500 时每个期权约 3 ms。收敛速度为 O(1/N)。

适用场景：美式期权，精度约为 0.5%（N=2000）或 约为 0.1%（N=10000）。也可用于通过令 N->inf 来验证 BS 实现的收敛性。

3. 三叉树 Boyle（trinomial）

具有 3 个分支（上涨/中间/下跌）的树。与二叉树类似，但数值条件更好。相同 N 下速度约为二叉树的 1.5 倍，但达到相同精度所需的步数约少 30%。

适用场景：二叉树出现异常波动时（T 较长、sigma 较高）。这是一个收敛性更稳定的替代方案。

4. 使用对偶变量的 Monte Carlo（mc）

模拟。仅支持欧式期权。O(paths)，paths=100k 时每个期权约 25 ms。 对偶变量可降低约 50-70% 的方差（有效样本数增加 2-3 倍）。

适用场景：路径依赖期权（亚洲期权、障碍期权、回望期权）——此 skill 尚未实现这些期权，但框架可扩展。带有 MC 噪声的 BS 验证。具有自定义收益的期权。

5. Longstaff-Schwartz（lsm）

用于美式期权的 Monte Carlo。通过对 S 的多项式进行最小二乘回归，以估算继续持有价值。O(paths * steps)，paths=100k、steps=50 时每个期权约 50 ms。

适用场景：BAW 不适用的复杂收益美式期权。多资产美式期权（篮子期权）。得出真实价格的下界。

额外：Barone-Adesi-Whaley（bs2）

用于美式期权的近似闭式解。O(1)，每个期权约 1.4 us——与 BS 一样快。与二叉树 N=2000 相比，误差 <1%。对于 q >= r，内部会回退到二叉树。

适用场景：大规模回测美式期权。需要每个期权 O(1) 时，可替代二叉树。

额外：隐含波动率（iv）

根据观察到的市场价格求解 sigma_impl。使用二分法，每次求解约 0.6 ms。欧式期权使用 BS；美式期权使用二叉树 N=500 作为定价引擎。

适用场景：已有市场价格，想推断市场所定价的波动率时。可作为波动率曲面和随机波动率模型的输入。

额外内容：P(ITM) 和 P(Profit)（pitm）

在风险中性 Q 测度下（并非现实世界）的概率，即期权在到期时处于 ITM 状态。 通过 N(d2) / N(-d2) 闭式计算，约为 300 ns/op。

• P(ITM)：看涨期权使用 N(d2)，看跌期权使用 N(-d2)
• P(Profit)：使用有效行权价 K +/- premium 计算 N(d2')

使用场景：在回测中筛选 P(Profit) > X% 的交易、计算期望值、比较权利金相同但 P(Profit) 不同的策略，以及使用 Kelly criterion 确定仓位大小。

注意：Q 测度下的漂移率为 r - q，而非现实世界中的漂移率。要计算 现实世界的概率，请将预期漂移率作为 r 传入（而非无风险利率）。

---

实用示例

对 SPY 上的 long-volatility 策略进行回测

# Para cada dia historico:
# 1. Obtener IV actual (e.g. de yahoo-finance) y precio de mercado
# 2. Calcular precio teorico con IV_historica
# 3. Comparar contra precio de mercado

# Precio teorico con IV_historica
py scripts/option_pricing.py bs --S 580 --K 580 --T 0.08 --r 0.05 --sigma 0.18
# -> 12.34

# Precio teorico con IV_actual (subestimada por el mercado)
py scripts/option_pricing.py bs --S 580 --K 580 --T 0.08 --r 0.05 --sigma 0.22
# -> 15.67

# P&L esperado = (market - teorico) = 15.67 - 12.34 = +3.33 (long vol paga)

计算整个期权链的 IV

# Para cada strike/expiry:
py scripts/option_pricing.py iv --S 580 --K 590 --T 0.08 --r 0.05 --price 8.50
# -> 0.2145 (la IV implicita de esa opcion)

用于 delta 对冲的 Greeks

py scripts/option_pricing.py greeks --S 580 --K 580 --T 0.08 --r 0.05 --sigma 0.20 --json
# Devuelve {delta: 0.512, gamma: 0.018, vega: 0.85, theta: -0.12, rho: 0.31}
# Comprar 1000 opc + short 512 acciones = delta neutral

对支付股息的标的计算美式期权定价

# Opcion sobre indice con yield alto (e.g. SPX con div yield ~1.5%)
py scripts/option_pricing.py bs2 --S 5800 --K 5800 --T 0.25 --r 0.05 --q 0.015 \
  --sigma 0.18 --type call --style american
# -> ~123.45 (vs BS europea ~120.10, premium de early exercise = $3.35)

比较所有适用的方法

all 模式会运行与所选 --style 兼容的所有方法， 以及实用工具（P(ITM)、P(Profit)、Greeks）。

# Ejemplo 1: American put (Hull 21.1)
py scripts/option_pricing.py all --S 50 --K 50 --T 0.4167 --r 0.10 --sigma 0.40 \
  --type put --style american
# Output (9 rows: BS, Binomial, Trinomial, MC, LSM, BS2, P(ITM), P(Profit), Greeks):
# +---------------------------+------------------+-----------------------+
# | Method                    | Config           | Price / Value         |
# +---------------------------+------------------+-----------------------+
# | Black-Scholes             | closed-form O(1) | 4.076101              | (europea ref)
# | Binomial CRR              | N=500            | 4.283160              |
# | Trinomial                 | N=500            | 4.283429              |
# | Monte Carlo               | paths=100000     | 4.077892 +/- 0.0254   | (europea)
# | Longstaff-Schwartz        | paths=100000     | 4.258337              |
# | BS2/BAW (closed-form)     | O(1)             | 4.283766              |
# | P(ITM)                    | N(d2) bajo Q     | 0.4871                |
# | P(Profit) vs BS price     | premio=4.0761    | 0.3588                |
# | Greeks (delta/gamma/vega) | BS closed-form   | d=-0.3857 g=+0.0296   |
# +---------------------------+------------------+-----------------------+

# Ejemplo 2: European call (incluye Heston y Bates, NO incluye LSM/BS2)
py scripts/option_pricing.py all --S 100 --K 100 --T 0.25 --r 0.05 --sigma 0.20
# Output (9 rows: BS, Binomial, Trinomial, MC, Heston, Bates, P(ITM), P(Profit), Greeks):
# +---------------------------+----------------------------------------+-----------------------+
# | Method                    | Config                                 | Price / Value         |
# +---------------------------+----------------------------------------+-----------------------+
# | Black-Scholes             | closed-form O(1)                       | 4.614997              |
# | Binomial CRR              | N=500                                  | 4.613001              |
# | Trinomial                 | N=500                                  | 4.613999              |
# | Monte Carlo               | paths=100000                           | 4.620907 +/- 0.0295   |
# | Heston 1993               | v0=s2, k=2, th=s2, sv=0.3, rho=-0.5    | 4.577095              |
# | Bates 1996                | Heston + lam=1, mu_J=-0.05, sig_J=0.10 | 4.924756              |
# | P(ITM)                    | N(d2) bajo Q                           | 0.5299                |
# | P(Profit) vs BS price     | premio=4.6150                          | 0.3534                |
# | Greeks (delta/gamma/vega) | BS closed-form                         | d=+0.5695 g=+0.0393   |
# +---------------------------+----------------------------------------+-----------------------+

all 的规则：

• --style american：包含 LSM 和 BS2（仅适用于美式期权的方法）
• --style european：包含 Heston 和 Bates（仅适用于欧式期权）
• 两者均包含：BS、Binomial、Trinomial、MC、P(ITM)、P(Profit)、Greeks

通过 all 调用时 Heston/Bates 的默认参数（针对典型的美国股票校准）为： v0=sigma^2, kappa=2, theta=v0, sigma_v=0.3, rho=-0.5, lambda=1, mu_J=-0.05, sigma_J=0.10。要使用自定义参数，请直接使用 heston / bates 模式。

---

不支持的用例

• 路径依赖期权（亚式、障碍、回望）：此 skill 仅为欧式期权 实现了 MC。可通过自定义 payoff 函数扩展框架。
• 多资产奇异期权（篮子、彩虹、价差）：可轻松扩展 LSM。 请逐个记录具体情况。
• 离散股息：模型假设 q 为连续股息收益率。 对于离散股息（例如已知日期），请使用等效的 q 或 调整模型。
• 随机波动率（Heston、SABR）：尚未实现。要回测这些模型， 需要使用其他库（QuantLib）。

---

大规模回测的性能提示

1. 尽可能使用 BS 或 BAW。它们比二叉树快约 2000 倍。
2. 避免不必要的内存分配：对于 1M 个期权的批次， 这些函数的复杂度已是 O(1)/op。纯 Python 中很难再进一步提升。
3. 重复使用 numpy.random.Generator：只创建一个实例，并将 seed 传给 MC/LSM。CLI 的默认实现已经使用 default_rng。
4. 向量化输入：此 skill 的函数接受标量。要对数组进行向量化， 可使用 np.vectorize(bs_price) 或手动映射。 如果使用 JIT 编译，numba 库可额外提速 10-50 倍。
5. 预计算公用因子：对于只改变 S 的批次， 预计算 T, r, q, sigma, K，并在循环中只改变 S。

---

验证

validate 模式会运行 assets/validation_cases.json 中的 10 个案例 （5 个欧式期权、4 个美式期权、1 个 put-call parity），并报告通过/失败：

py scripts/option_pricing.py validate
# === Black-Scholes European ===
#   [OK] Hull 9th ed Example 15.6 (ATM call): got 4.7594, ref 4.7594
#   [OK] ... (5/5 pass)
# === American (Binomial N=2000) ===
#   [OK] Hull 9th ed Example 21.1: got 4.2841, ref 4.2841
#   [OK] ... (4/4 pass)
# === Put-Call Parity (BS) ===
#   [OK] C - P = 4.8770575499, S*exp(-qT) - K*exp(-rT) = 4.8770575499
# 0 failure(s)

要添加自定义案例，请编辑 assets/validation_cases.json。

---

作为库使用 API（不只是 CLI）

可直接在 Python 中导入这些函数：

from scripts.option_pricing import bs_price, binomial_price, mc_european_price, lsm_price, bs2_american_price, bs_greeks, implied_vol

# Pricing
c = bs_price(100, 100, 0.25, 0.05, 0.0, 0.20, "call")     # 4.615
p = binomial_price(100, 100, 0.25, 0.05, 0.0, 0.20, 500, "put", "european")

# Greeks (solo BS)
g = bs_greeks(100, 100, 0.25, 0.05, 0.0, 0.20, "call")
# -> {"delta": 0.569, "gamma": 0.039, "vega": 19.64, "theta": -10.47, "rho": 13.08}

# Implied vol
iv = implied_vol(4.62, 100, 100, 0.25, 0.05, 0.0, "call", "european")
# -> 0.2003

所有函数都是扁平函数（无类），接受标量并返回浮点数。对于向量， 请使用 np.vectorize 或列表推导式。

---

许可证

MIT