科研 Skill
期权定价与希腊字母
options-pricing
Covers Black-Scholes pricing, Monte Carlo with variance reduction, binomial trees, Greeks, and implied-volatility surfaces. Use for option-valuation or derivatives-pricing research.
SKILL.md
Options Pricing
TL;DR — Price European and American options using Black-Scholes analytics, Monte Carlo simulation with antithetic variates and control variates, and CRR binomial trees. Compute all Greeks, extract implied volatility with Brent's method, and visualize the implied volatility surface and smile.
When to Use
| Situation | Recommended Method |
|---|---|
| European call/put, closed-form price | Black-Scholes formula |
| All five Greeks for a European option | Analytical BS Greeks |
| Confidence interval around MC price | Monte Carlo + standard error |
| Reduce MC variance | Antithetic variates / control variate |
| American option (early exercise) | Binomial CRR tree (backward induction) |
| Extract market-implied vol from option price | Brent root-finding on BS formula |
| Visualize vol smile/surface | Plot IV by strike and maturity |
Background
Black-Scholes-Merton Model (1973)
Assumes the underlying S_t follows GBM: dS_t = μ S_t dt + σ S_t dW_t
European call price: C = S N(d₁) - K e^{-rT} N(d₂) d₁ = [ln(S/K) + (r + σ²/2)T] / (σ√T) d₂ = d₁ - σ√T
European put: P = K e^{-rT} N(-d₂) - S N(-d₁)
Greeks
| Greek | Definition | Formula |
|---|---|---|
| Delta | ∂C/∂S | N(d₁) (call) |
| Gamma | ∂²C/∂S² | φ(d₁)/(S σ √T) |
| Vega | ∂C/∂σ | S φ(d₁) √T |
| Theta | ∂C/∂t | -(S φ(d₁) σ)/(2√T) - rK e^{-rT} N(d₂) |
| Rho | ∂C/∂r | K T e^{-rT} N(d₂) (call) |
Monte Carlo Variance Reduction
Antithetic variates: For each path ε_t, also simulate -ε_t. Pair estimates and average. Reduces variance by exploiting negative correlation between paired paths.
Control variate: Use BS analytical price as control: C_CV = C_MC + β (C_BS - E[C_BS]) where β = Cov(C_MC, C_control) / Var(C_control) ≈ 1 for European options.
Effective variance reduction factor can be 5–50x depending on the payoff.
CRR Binomial Tree
Cox-Ross-Rubinstein (1979) recombining tree:
- Up factor: u = e^{σ√Δt}
- Down factor: d = 1/u
- Risk-neutral probability: p = (e^{rΔt} - d) / (u - d)
American option: at each node, take the maximum of intrinsic value and continuation value (backward induction). European option: only backward induction without early exercise check.
Implied Volatility
Given observed market price C_mkt, find σ_IV such that: BS(S, K, T, r, σ_IV) = C_mkt
Solved numerically via scipy.optimize.brentq (Brent's method) over σ ∈ (0.001, 10).
Environment Setup
conda create -n options python=3.11 -y
conda activate options
pip install numpy>=1.23 scipy>=1.9 matplotlib>=3.6 pandas>=1.5
python -c "import numpy, scipy, matplotlib; print('All packages OK')"
No external financial data API required. All examples use synthetic parameters.
Core Workflow
Step 1 — Black-Scholes Pricing and All Greeks
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.stats import norm
from scipy.optimize import brentq
import warnings
def bs_price(
S: float,
K: float,
T: float,
r: float,
sigma: float,
option_type: str = "call",
) -> float:
"""
Black-Scholes-Merton European option price.
Args:
S: Current underlying price.
K: Strike price.
T: Time to expiry in years.
r: Continuously compounded risk-free rate.
sigma: Implied/historical volatility (annualized).
option_type: 'call' or 'put'.
Returns:
Option price.
"""
if T <= 0:
if option_type == "call":
return max(S - K, 0)
return max(K - S, 0)
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)
elif option_type == "put":
return K * np.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)
else:
raise ValueError(f"option_type must be 'call' or 'put', got '{option_type}'")
def bs_greeks(
S: float,
K: float,
T: float,
r: float,
sigma: float,
option_type: str = "call",
) -> dict:
"""
Compute all five Black-Scholes Greeks analytically.
Args:
S: Underlying price.
K: Strike price.
T: Time to expiry in years.
r: Risk-free rate (continuously compounded).
sigma: Volatility (annualized).
option_type: 'call' or 'put'.
Returns:
Dictionary with keys: delta, gamma, vega, theta, rho.
Theta is per calendar day (divided by 365).
"""
d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
phi_d1 = norm.pdf(d1)
gamma = phi_d1 / (S * sigma * np.sqrt(T))
vega = S * phi_d1 * np.sqrt(T)
if option_type == "call":
delta = norm.cdf(d1)
theta = (-(S * phi_d1 * sigma) / (2 * np.sqrt(T))
- r * K * np.exp(-r * T) * norm.cdf(d2)) / 365
rho = K * T * np.exp(-r * T) * norm.cdf(d2)
elif option_type == "put":
delta = norm.cdf(d1) - 1
theta = (-(S * phi_d1 * sigma) / (2 * np.sqrt(T))
+ r * K * np.exp(-r * T) * norm.cdf(-d2)) / 365
rho = -K * T * np.exp(-r * T) * norm.cdf(-d2)
else:
raise ValueError(f"option_type must be 'call' or 'put'")
return {"delta": delta, "gamma": gamma, "vega": vega,
"theta": theta, "rho": rho}
def print_greeks_table(
S: float = 100.0,
K: float = 100.0,
T: float = 1.0,
r: float = 0.05,
sigma: float = 0.20,
) -> pd.DataFrame:
"""
Print a formatted table of BS prices and Greeks for call and put.
Args:
S, K, T, r, sigma: Standard Black-Scholes parameters.
Returns:
DataFrame with rows for call and put, columns for price and Greeks.
"""
call_price = bs_price(S, K, T, r, sigma, "call")
put_price = bs_price(S, K, T, r, sigma, "put")
call_greeks = bs_greeks(S, K, T, r, sigma, "call")
put_greeks = bs_greeks(S, K, T, r, sigma, "put")
parity_check = call_price - put_price - (S - K * np.exp(-r * T))
print(f"Put-Call Parity check: {parity_check:.2e} (should be ~0)")
rows = []
for opt_type, price, greeks in [("call", call_price, call_greeks),
("put", put_price, put_greeks)]:
rows.append({
"type": opt_type,
"price": round(price, 4),
"delta": round(greeks["delta"], 4),
"gamma": round(greeks["gamma"], 4),
"vega": round(greeks["vega"], 4),
"theta (per day)": round(greeks["theta"], 4),
"rho": round(greeks["rho"], 4),
})
df = pd.DataFrame(rows)
print(f"\nBS Option Parameters: S={S}, K={K}, T={T}y, r={r:.2%}, σ={sigma:.2%}")
print(df.to_string(index=False))
return df
Step 2 — Monte Carlo with Antithetic and Control Variates
def mc_option_price(
S: float,
K: float,
T: float,
r: float,
sigma: float,
option_type: str = "call",
n_paths: int = 100_000,
n_steps: int = 1,
use_antithetic: bool = True,
use_control_variate: bool = True,
seed: int = 42,
) -> dict:
"""
Monte Carlo European option pricing with variance reduction.
Args:
S: Initial underlying price.
K: Strike price.
T: Time to expiry (years).
r: Risk-free rate.
sigma: Volatility.
option_type: 'call' or 'put'.
n_paths: Number of GBM simulation paths.
n_steps: Time steps per path (1 = log-normal terminal price).
use_antithetic: Apply antithetic variates variance reduction.
use_control_variate: Apply control variate (BS price).
seed: Random seed.
Returns:
Dictionary with keys: price, se, ci_lower, ci_upper, bs_price, variance_reduction.
"""
rng = np.random.default_rng(seed)
dt = T / n_steps
if use_antithetic:
half = n_paths // 2
Z = rng.standard_normal((half, n_steps))
Z_all = np.vstack([Z, -Z])
else:
Z_all = rng.standard_normal((n_paths, n_steps))
# GBM simulation
log_S = np.log(S) + np.cumsum(
(r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z_all, axis=1
)
S_T = np.exp(log_S[:, -1])
# Payoff
if option_type == "call":
payoffs = np.maximum(S_T - K, 0)
else:
payoffs = np.maximum(K - S_T, 0)
# Discount
payoffs_disc = np.exp(-r * T) * payoffs
price_plain = float(np.mean(payoffs_disc))
# Control variate: BS price as control
if use_control_variate:
bs_ref = bs_price(S, K, T, r, sigma, option_type)
cov_matrix = np.cov(payoffs_disc, payoffs_disc) # Placeholder; use S_T as control
# Use S_T as a traded asset: known E[e^{-rT} S_T] = S (forward price)
s_t_disc = np.exp(-r * T) * S_T
beta = np.cov(payoffs_disc, s_t_disc)[0, 1] / np.var(s_t_disc)
payoffs_cv = payoffs_disc - beta * (s_t_disc - S)
price_cv = float(np.mean(payoffs_cv))
se_cv = float(np.std(payoffs_cv) / np.sqrt(n_paths))
var_reduction = float(np.var(payoffs_disc) / np.var(payoffs_cv))
price_final = price_cv
se_final = se_cv
else:
bs_ref = bs_price(S, K, T, r, sigma, option_type)
var_reduction = 1.0
price_final = price_plain
se_final = float(np.std(payoffs_disc) / np.sqrt(n_paths))
ci_lower = price_final - 1.96 * se_final
ci_upper = price_final + 1.96 * se_final
print(f"\nMC {option_type.upper()} Price: {price_final:.4f} SE: {se_final:.4f}")
print(f" 95% CI: [{ci_lower:.4f}, {ci_upper:.4f}]")
print(f" BS price: {bs_ref:.4f} | Variance reduction factor: {var_reduction:.2f}x")
return {"price": price_final, "se": se_final,
"ci_lower": ci_lower, "ci_upper": ci_upper,
"bs_price": bs_ref, "variance_reduction": var_reduction}
Step 3 — Implied Volatility Surface
def implied_vol(
market_price: float,
S: float,
K: float,
T: float,
r: float,
option_type: str = "call",
tol: float = 1e-8,
) -> float:
"""
Extract implied volatility from an observed market price using Brent's method.
Args:
market_price: Observed option price in the market.
S: Current underlying price.
K: Strike.
T: Time to expiry.
r: Risk-free rate.
option_type: 'call' or 'put'.
tol: Solver tolerance.
Returns:
Implied volatility, or np.nan if no solution found.
"""
intrinsic = max(S - K * np.exp(-r * T), 0) if option_type == "call" else max(K * np.exp(-r * T) - S, 0)
if market_price < intrinsic:
return np.nan
def objective(sigma):
return bs_price(S, K, T, r, sigma, option_type) - market_price
try:
iv = brentq(objective, 1e-4, 10.0, xtol=tol, full_output=False)
return float(iv)
except (ValueError, RuntimeError):
return np.nan
def implied_vol_surface(
S: float = 100.0,
r: float = 0.03,
strikes: list = None,
maturities: list = None,
sigma_atm: float = 0.20,
skew: float = -0.02,
term_slope: float = 0.01,
output_path: str = None,
) -> pd.DataFrame:
"""
Generate a synthetic implied vol surface and plot as heatmap.
Synthetic IV surface: σ(K, T) = σ_ATM + skew × moneyness + term_slope × T
Args:
S: Current price.
r: Risk-free rate.
strikes: List of strikes. Default: S × [0.8, 0.85, ..., 1.2].
maturities: List of maturities in years. Default: [0.25, 0.5, 1.0, 1.5, 2.0].
sigma_atm: ATM implied vol level.
skew: Slope of vol smile with moneyness (ln(K/S)).
term_slope: Term structure slope per year.
output_path: If provided, save heatmap.
Returns:
DataFrame of implied vols: rows = maturities, columns = strikes.
"""
if strikes is None:
strikes = [round(S * m, 1) for m in np.arange(0.80, 1.21, 0.05)]
if maturities is None:
maturities = [0.25, 0.5, 1.0, 1.5, 2.0]
iv_matrix = {}
for T in maturities:
row = {}
for K in strikes:
moneyness = np.log(K / S)
iv_synth = sigma_atm + skew * moneyness + term_slope * T
iv_synth = max(0.05, iv_synth)
# Generate market price and recover IV for self-consistency
mkt_price = bs_price(S, K, T, r, iv_synth, "call")
iv_rec = implied_vol(mkt_price, S, K, T, r, "call")
row[K] = round(iv_rec if not np.isnan(iv_rec) else iv_synth, 4)
iv_matrix[T] = row
iv_df = pd.DataFrame(iv_matrix).T
iv_df.index.name = "Maturity"
# Plot heatmap
fig, axes = plt.subplots(1, 2, figsize=(15, 5))
# Heatmap
im = axes[0].imshow(iv_df.values, aspect="auto", cmap="RdYlGn_r",
vmin=iv_df.values.min() * 0.95, vmax=iv_df.values.max() * 1.05)
axes[0].set_xticks(range(len(strikes)))
axes[0].set_xticklabels([str(k) for k in strikes], rotation=45, fontsize=8)
axes[0].set_yticks(range(len(maturities)))
axes[0].set_yticklabels([f"{m}y" for m in maturities])
axes[0].set_xlabel("Strike")
axes[0].set_ylabel("Maturity")
axes[0].set_title("Implied Volatility Surface (Heatmap)")
plt.colorbar(im, ax=axes[0])
# Vol smile (cross-section at each maturity)
for T in maturities:
axes[1].plot(strikes, iv_df.loc[T].values, "o-", label=f"T={T}y", linewidth=1.5)
axes[1].set_xlabel("Strike")
axes[1].set_ylabel("Implied Volatility")
axes[1].set_title("Implied Volatility Smile by Maturity")
axes[1].legend(fontsize=8)
fig.tight_layout()
if output_path:
fig.savefig(output_path, dpi=150)
print(f"Saved IV surface to {output_path}")
plt.show()
return iv_df
Advanced Usage
CRR Binomial Tree for American Options
def binomial_tree_price(
S: float,
K: float,
T: float,
r: float,
sigma: float,
n_steps: int = 200,
option_type: str = "call",
american: bool = True,
) -> float:
"""
CRR binomial tree pricing for European and American options.
Args:
S: Underlying price.
K: Strike.
T: Time to expiry.
r: Risk-free rate.
sigma: Volatility.
n_steps: Number of time steps (higher = more accurate).
option_type: 'call' or 'put'.
american: If True, allow early exercise (American option).
Returns:
Option price.
"""
dt = T / n_steps
u = np.exp(sigma * np.sqrt(dt))
d = 1.0 / u
p = (np.exp(r * dt) - d) / (u - d)
disc = np.exp(-r * dt)
# Terminal stock prices
j = np.arange(n_steps + 1)
S_T = S * u ** (n_steps - 2 * j)
# Terminal payoffs
if option_type == "call":
V = np.maximum(S_T - K, 0)
else:
V = np.maximum(K - S_T, 0)
# Backward induction
for i in range(n_steps - 1, -1, -1):
V = disc * (p * V[:-1] + (1 - p) * V[1:])
if american:
j_i = np.arange(i + 1)
S_node = S * u ** (i - 2 * j_i)
if option_type == "call":
intrinsic = np.maximum(S_node - K, 0)
else:
intrinsic = np.maximum(K - S_node, 0)
V = np.maximum(V, intrinsic)
return float(V[0])
def early_exercise_premium(
S: float = 100.0,
K: float = 100.0,
T: float = 1.0,
r: float = 0.05,
sigma: float = 0.20,
) -> dict:
"""
Compute early exercise premium: American price - European price.
For calls on non-dividend paying stocks, this should be ~0 (no early exercise).
For puts, the premium is positive.
Args:
S, K, T, r, sigma: Standard option parameters.
Returns:
Dictionary with european_call, american_call, european_put, american_put,
call_premium, put_premium.
"""
eur_call = bs_price(S, K, T, r, sigma, "call")
eur_put = bs_price(S, K, T, r, sigma, "put")
amer_call = binomial_tree_price(S, K, T, r, sigma, n_steps=300, option_type="call", american=True)
amer_put = binomial_tree_price(S, K, T, r, sigma, n_steps=300, option_type="put", american=True)
call_prem = amer_call - eur_call
put_prem = amer_put - eur_put
print(f"\nEarly Exercise Premiums (S={S}, K={K}, T={T}, r={r:.1%}, σ={sigma:.1%}):")
print(f" Call: European={eur_call:.4f} American={amer_call:.4f} Premium={call_prem:.4f}")
print(f" Put: European={eur_put:.4f} American={amer_put:.4f} Premium={put_prem:.4f}")
return {"european_call": eur_call, "american_call": amer_call,
"european_put": eur_put, "american_put": amer_put,
"call_premium": call_prem, "put_premium": put_prem}
Troubleshooting
| Error / Issue | Cause | Resolution |
|---|---|---|
brentq raises ValueError | Market price below intrinsic or above S | Check arbitrage: intrinsic ≤ mkt_price ≤ S |
| IV = NaN for deep OTM options | Very low market price, solver loses bracket | Widen sigma bounds to (1e-5, 20.0) |
| MC price converges slowly | Too few paths | Use n_paths=500_000 or apply variance reduction |
| Binomial tree slow for large n_steps | O(n²) computation | Reduce to n_steps=200 for daily practice |
| BS Theta > 0 for deep ITM put | Theta can be positive for deep ITM puts | This is mathematically correct; not an error |
| Gamma → ∞ as T → 0 at-the-money | Near-expiry ATM option | Clip T at minimum 1e-6; expected behavior |
External Resources
- Black, F., Scholes, M. (1973). "The Pricing of Options and Corporate Liabilities." Journal of Political Economy, 81(3), 637–654.
- Merton, R.C. (1973). "Theory of Rational Option Pricing." Bell Journal of Economics, 4(1), 141–183.
- Cox, J., Ross, S., Rubinstein, M. (1979). "Option Pricing: A Simplified Approach." Journal of Financial Economics, 7(3), 229–263.
- Hull, J.C. (2022). Options, Futures, and Other Derivatives, 11th Edition. Pearson.
- Glasserman, P. (2004). Monte Carlo Methods in Financial Engineering. Springer.
Examples
Example 1 — BS Price + Greeks Parameter Table
greeks_df = print_greeks_table(S=100, K=105, T=0.5, r=0.04, sigma=0.25)
# Vary spot price and plot Delta profile
spots = np.linspace(60, 140, 100)
deltas_call = [bs_greeks(s, 100, 0.5, 0.04, 0.25, "call")["delta"] for s in spots]
deltas_put = [bs_greeks(s, 100, 0.5, 0.04, 0.25, "put")["delta"] for s in spots]
plt.figure(figsize=(9, 4))
plt.plot(spots, deltas_call, label="Call Delta", color="#2980B9")
plt.plot(spots, deltas_put, label="Put Delta", color="#E74C3C")
plt.axvline(100, color="gray", linestyle=":", linewidth=1, label="ATM")
plt.xlabel("Spot Price")
plt.ylabel("Delta")
plt.title("Delta Profile vs Spot")
plt.legend()
plt.tight_layout()
plt.savefig("delta_profile.png", dpi=150)
plt.show()
Example 2 — MC vs BS with Variance Reduction + IV Surface
# Monte Carlo with antithetic + control variate
mc_result = mc_option_price(
S=100, K=100, T=1.0, r=0.05, sigma=0.20, option_type="call",
n_paths=100_000, use_antithetic=True, use_control_variate=True,
)
print(f"BS price: {mc_result['bs_price']:.4f} | MC price: {mc_result['price']:.4f}")
# American vs European put early exercise premium
premium = early_exercise_premium(S=100, K=110, T=1.0, r=0.05, sigma=0.25)
# Implied vol surface
iv_df = implied_vol_surface(
S=100, r=0.03, sigma_atm=0.20, skew=-0.03, term_slope=0.01,
output_path="iv_surface.png"
)
print("\nIV Surface (maturity × strike):")
print(iv_df.round(4))
Changelog
| Version | Date | Change |
|---|---|---|
| 1.0.0 | 2026-03-18 | Initial release — BS pricing, Greeks, MC variance reduction, CRR tree, IV surface |
示例提示词
我想用Black-Scholes和蒙特卡洛方法计算期权价格和隐含波动率曲面。
所属插件
安装该插件会一并获得同领域的 40 个 Skill / MCP。
同插件的其他科研 Skill
- 文献计量分析Runs bibliometric and co-citation analysis for management or economics literature reviews using CiteSpace, VOSviewer, or bibliometrix. Use for citation-network mapping.
- 发展经济学与RCT分析Loads LSMS data and runs RCT ITT analysis, Lee sharp bounds, covariate balance tables, propensity-score matching, and FGT poverty indices. Use for development-economics impact or poverty research.
- 双重差分因果推断Estimates DiD effects with two-way fixed effects, parallel-trends tests, Callaway-Sant’Anna staggered estimators, and Goodman-Bacon decomposition. Use for staggered or two-period DiD designs.
- 宏观经济预测Runs ARIMA, VAR, LightGBM ensemble forecasting, Diebold-Mariano tests, fan charts, and real-time ALFRED data. Use for macroeconomic forecasting or forecast-accuracy comparison.
- 金融事件研究法Estimates abnormal returns, CARs, BMP tests, and Fama-French normal returns plus long-run BHAR using yfinance. Use for a corporate-finance event-study around an announcement date.
- 实验经济学设计Designs incentivized lab, online, or lab-in-field experiments: treatment and payoff design, deception/IRB norms, and oTree/z-Tree setup. Use when designing a behavioral-economics study.
- 资产定价因子模型Fits Fama-French 3/5-factor, Carhart 4-factor, and q-factor asset-pricing models with rolling loadings and the GRS alpha test. Use for asset-pricing factor-model estimation.
- 金融时间序列分析Covers GARCH volatility modeling, cointegration, pairs trading, factor models, and risk decomposition for financial time series. Use for volatility or financial time-series research.
- 固定收益证券分析Covers bond pricing, yield curves, duration/convexity, Nelson-Siegel fitting, and credit-spread modeling. Use for fixed-income analytics or term-structure research.
- FRED宏观数据分析Fetches and analyzes FRED series via fredapi: GDP, unemployment, inflation, yield curves, recession shading, and HP filtering. Use for US macroeconomic time-series retrieval and analysis.
- 工具变量两阶段最小二乘Runs IV/2SLS with first-stage diagnostics, Wu-Hausman endogeneity, Sargan overidentification, and weak-instrument tests via linearmodels. Use for IV estimation of an endogenous regressor.
- 劳动经济学分析Estimates Mincer wage equations, Heckman selection, Oaxaca-Blinder decomposition, and unconditional quantile regression on CPS data. Use for labor-economics wage or selection research.
- 管理学实证研究图表為管理/財務實證研究產出出版級統計圖:轉折點圖、係數森林圖、交互作用圖、事件研究CAR曲線。用於迴歸或追蹤資料結果需要投稿圖表時。
- 中国情境因果推断方法提供DiD/RDD/IV/合成控制/PSM识别策略的Stata/R/Python模板,附中国数据陷阱。适用于CSMAR/Wind/CFPS数据的因果识别。
- 经管学术图表模板集提供12种经管高频图表的Stata/R/Python三语言模板,支持4种期刊样式切换。适用于绘制经管学术图表、事件研究可视化或政策评估图。
- CSMAR数据清洗SOP提供CSMAR数据清洗SOP:ST剔除、缩尾标准、公司ID追踪、行业代码映射与时间对齐模板。适用于处理CSMAR数据或构建经管类面板数据。
- 研究流程与因果图绘制自动生成研究流程图、因果DAG、PRISMA图与网络图,提供Mermaid/Python/LaTeX TikZ模板。适用于绘制论文流程图或因果识别可视化。
- 科研资助申请书写作覆盖国内外主流科研资助项目的写作助手,提供项目对比、各模块写作提示与预算编制规范。适用于撰写国家社科基金、NSF、ERC等资助申请书。
- 管理学期刊投稿图表按目标期刊生成投稿级图表规格,强调矢量PDF、字体嵌入、色盲友好与可复现脚本。适用于准备特定期刊风格的图表或审查图表质量。
- 论文投稿材料整理覆盖论文材料盘点、证据矩阵、章节撰写与预投稿package整理,含cover letter与补充材料清单。适用于把研究项目整理成可投稿的完整论文包。
- 混合方法研究设计覆盖探索型/解释型顺序设计、并行汇聚设计、joint display与方法整合段落写作。适用于连接访谈/案例与问卷/实验数据的混合方法论文设计。
- 国自然基金申请书写作提供NSFC面上/青年/重点等8类项目的立项依据、研究内容、预算编制模板与退稿信号清单。适用于撰写、修改或审阅国家自然科学基金申请书。
- 论文项目进度管理提供论文项目的任务拆解、看板、里程碑、风险登记与周计划模板,适用于管理论文进度、协调合作者或安排修订冲刺与会议纪要整理。
- 中文期刊配图规范提供中文学术期刊配图规范与matplotlib模板:三线表、宋体字号、色盲友好调色板与7类常用图。适用于绘制符合中文期刊规范的学术图表。
常见问题
期权定价与希腊字母能做什么?
Covers Black-Scholes pricing, Monte Carlo with variance reduction, binomial trees, Greeks, and implied-volatility surfaces. Use for option-valuation or derivatives-pricing research。
如何安装期权定价与希腊字母?
在科搭 Codar 左侧点击「插件」,在「组件」页签搜索「期权定价与希腊字母」并安装;在 Claude Code 或 Codex 中可以发送本页的安装提示词,或下载 Skill 包后解压到 ~/.claude/skills 或 ~/.codex/skills。
期权定价与希腊字母需要哪些权限?
该科研 Skill没有声明额外权限;执行具体操作时仍由 Agent 按自身规则请求确认。
期权定价与希腊字母经过官方审核吗?
是。SpeedSkills 收录的每个版本都会记录内容摘要与权限声明,当前版本已通过安全审核。