pdeSolver 金融衍生品定价教程

金融衍生品的价格取决于标的价格、时间、波动率等状态变量。PDE 求解器会先把这些变量划分成网格，再从到期日的收益开始，逐步向当前时刻倒推，计算出不同状态下的理论价格。

因此，PDE 求解器的作用不只是给出一个价格，还可以一次得到一整张价格面，并在同一框架下处理美式期权的提前行权、障碍期权的边界条件、随时间变化的参数以及较复杂的收益结构。

PDE 方法适合状态变量较少的问题。状态维度增加后，网格规模会迅速扩大：二维问题通常需要 ADI 等专门方法，三维及以上问题则要结合计算成本考虑其他数值方法。

pdeSolver 主要用于求解一维和二维线性抛物型 PDE，采用有限差分法（FDM），支持结构化均匀网格和非均匀网格，以及常用的 Dirichlet、Neumann 和 Robin 边界条件。此外，它还支持一维障碍问题和二维交替方向隐式（ADI）方法。

需要注意的是，pdeSolver 并非通用的微分方程求解器。目前，它暂不支持非结构化网格、三维问题、有限元法（FEM）、有限体积法（FVM）、强非线性问题和二维障碍定价。详见 pdeSolver 官方文档。

• 时间用剩余期限 $\tau =T-t$ ，从到期日的 $\tau =0$ 向估值日推进。

• 贴现利率和股息/便利收益率采用连续复利，波动率按年化标准差计。

• 一维坐标多取 $S$ ，二维可能取 $(S_1,S_2)$ 或 $(x=\ln S,v)$ ；坐标必须在系数、初值和边界中一致。

• 文中的定价价值、现金流和边界均基于明确的示例约定；交易条款必须由客户实际 payoff、观察方式和结算规则决定。

• 严格区分模型误差、截断误差、空间误差、时间误差、迭代误差与 Monte Carlo 统计误差。

如果你第一次接触 pdeSolver，先运行下面这个最小例子。它只做一件事：用一维 PDE 计算一个 European Call 在 S=100 处的价格。模型推导、边界含义和结果对照说明见 4.1 European Call 与 European Put。

spot = 100.0        //股票当前价格
strike = 100.0      //执行价格
rate = 0.03         //无风险利率
dividend = 0.01     //股息率
volatility = 0.20   //波动率
finalTime = 1.0     //期权的剩余期限
spotMax = 400.0     //股票价格上边界

// DolphinDB 的匿名函数在顶层不捕获外部变量；把系数和边界放入函数作用域。
def makeQuickBSCase(vol, rate, dividend, strike, spotMax) {
    coeff = pdeCoeff1D(
        diff={S,tau -> 0.5 * vol * vol * S * S},
        conv={S,tau -> (rate-dividend) * S},
        react=-rate
    )
    payoff = {S -> max(S-strike, 0.0)}
    boundary = [
        {tau -> 0.0},
        {tau -> spotMax*exp(-dividend*tau) - strike*exp(-rate*tau)}
    ]
    return coeff, payoff, boundary
}
coeff, payoff, boundary = makeQuickBSCase(volatility, rate, dividend, strike, spotMax)
spotGrid = pdeGrid1D(0.0, spotMax, 401, "sinh", strike, 3.0)
tGrid = (0..400) * finalTime / 400.0

setting = dict(STRING, ANY)
setting["interpAt"] = spot
result = pdeSolver(
    coeff, payoff, pdeDomain1D(spotGrid), tGrid,
    boundary, dict(STRING, ANY), setting
)
result["interpValue"]

在本教程的固定参数下，输出应接近期权解析解 8.8269。

先认识几个词

• payoff：到期收益函数，例如 Call 的 $max(S-K,0)$ 。

• obstacle：美式期权的提前行权约束，要求数值解不低于立即行权收益。

• PSOR：处理美式期权离散互补问题的一种逐点迭代方法。

• ADI：把二维问题拆成多个方向子步的交替方向隐式方法。

• callback：由用户定义、在求解过程中提供系数或边界值的函数。

常用术语速查见附录 B。

在连续股息率为 q 的 Black–Scholes 模型下，风险中性测度中的标的过程为

$d{S}_t=(r-q)S_{t}dt+\sigma S_{t}d{W}_t^{\mathbb{Q}}$

对足够光滑的价格函数 V(t,S)，Itô 引理给出

$dV=V_{t}dt+V_{S}dS+\frac{1}{2}{\sigma }^2{S}^2{V}_{SS}dt$

由复制组合消除随机项或由 Feynman–Kac 定理，可得定价 PDE

$V_t+\frac{1}{2}{\sigma }^2{S}^2{V}_{SS}+(r-q)S{V}_S-rV=0$

欧式看涨与看跌共用同一个 PDE，差别由到期收益决定：

${\Phi }_C(S)=max(S-K,0),{\Phi }_P(S)=max(K-S,0)$

令 $u(S,\tau )=V(T-\tau ,S)$ ，因为 $V_t=-u_{\tau }$ ，故

$u_{\tau }=\frac{1}{2}{\sigma }^2{S}^2{u}_{SS}+(r-q)S{u}_S-ru,u(S,0)=\Phi (S)$

把这一式写成 pdeSolver 的一维标准形式：

$M{u}_{\tau }=A{u}_{SS}+B{u}_S+Cu+D$

若两个 Brownian 运动满足 $d{W}_{1}d{W}_2=\rho dt$ ，生成元中的交叉项是

$\rho {\sigma }_1{\sigma }_2{S}_1{S}_2{V}_{S_1{S}_2}$

这里没有额外的 1/2：它来自 Itô 展开中两项相同混合二阶导数的合并。pdeCoeff2D(xy=...) 输入的就是这一完整系数，不是协方差项的一半。

二维标准形式为

$M{u}_{\tau }=A{u}_{xx}+B{u}_{yy}+C{u}_{xy}+D{u}_x+E{u}_y+Fu+G$

欧式 Call 的典型远端边界为 $S_{max}{e}^{-q\tau }-K{e}^{-r\tau }$ ；欧式 Put 的左端边界为 $K{e}^{-r\tau }$ 。美式 Put 在常见非负利率、无股息模型下左端边界则为 K：两者不能混用。

总误差不应被一个“相对误差”数字掩盖。将同一组参数下的误差概念性地拆成

$E_{total}\lesssim E_{model}+E_{domain}+E_{space}+E_{time}+E_{boundary}+E_{iteration}+E_{interpolation}$

若使用 MC 基准，还应报告统计误差（标准误）。其中 $E_{model}$ 属于产品假设与市场模型本身，并不能通过加密网格消除。

method 用于选择时间推进、对流离散、ADI/obstacle 及资源配置；setting 用于返回模式、时间层、插值、Greeks 和诊断。不要把这两种字典的字段混用。interpAt 应位于定义域内；resultMode="detail" 可在验证阶段配合 diagnostics=true 使用。

产品与假设。仅在到期行权；同一风险中性模型下，两种 payoff 不同，PDE 相同。此模板是验证定价器符号与边界的首选入口。

推导与映射。 $u_{\tau }=\frac{1}{2}{\sigma }^2{S}^2{u}_{SS}+(r-q)S{u}_S-ru$ ， $diff=\frac{1}{2}{\sigma }^2{S}^2,conv=(r-q)S,react=-r$ 。Call 左端为 0；Put 左端必须是 $K{e}^{-r\tau }$ ，不应沿用美式 Put 的 K。右端 Call 使用渐近线性边界，Put 使用 0。

样例参数。 $S_0=K=100,r=3\%,q=1\%,\sigma =20\%,T=1$ ；网格聚焦在 K。

DolphinDB 完整示例

def makeBS1DCase(volatility, rate, dividend, strike, spotMax, productType) {
    coeff = pdeCoeff1D(
        diff={S,tau -> 0.5 * volatility * volatility * S * S},
        conv={S,tau -> (rate-dividend) * S},
        react=-rate
    )

    if (productType == "call") {
        payoff = {S -> max(S-strike, 0.0)}
        boundary = [
            {tau -> 0.0},
            {tau -> spotMax*exp(-dividend*tau) - strike*exp(-rate*tau)}
        ]
    } else {
        payoff = {S -> max(strike-S, 0.0)}
        boundary = [{tau -> strike*exp(-rate*tau)}, 0.0]
    }
    return coeff, payoff, boundary
}

spot = 100.0
strike = 100.0
rate = 0.03
dividend = 0.01
volatility = 0.20
finalTime = 1.0
spotMax = 400.0

spotGrid = pdeGrid1D(0.0, spotMax, 401, "sinh", strike, 3.0)
tGrid = (0..400) * finalTime / 400.0
coeff, payoff, boundary = makeBS1DCase(volatility, rate, dividend, strike, spotMax, "call")

method = dict(STRING, ANY)
method["rannacherSteps"] = 2
setting = dict(STRING, ANY)
setting["interpAt"] = spot

result = pdeSolver(
    coeff, payoff, pdeDomain1D(spotGrid), tGrid,
    boundary, method, setting
)
pdePrice = result["interpValue"]
d1 = (log(spot/strike) + (rate-dividend+0.5*volatility*volatility)*finalTime) / (volatility*sqrt(finalTime))
d2 = d1 - volatility*sqrt(finalTime)
reference = spot*exp(-dividend*finalTime)*cdfNormal(0.0,1.0,d1) - strike*exp(-rate*finalTime)*cdfNormal(0.0,1.0,d2)
relativeError = abs(pdePrice-reference) / max(abs(reference), 1e-12)
summary = dict(STRING, ANY)
summary["pdePrice"] = pdePrice
summary["closedFormPrice"] = reference
summary["relativeError"] = relativeError
summary

解析结果： Call = 8.82732123；Put = 6.86689121。解析 Put-Call Parity：

$C-P=S_0{e}^{-qT}-K{e}^{-rT}$ 。

可选结果核对： 报告每种产品的 pdePrice、reference、绝对误差和相对误差；网格 $N_x=101/201/401/801、N_t=100/200/400/800$ 分别加密，并用 $S_{max}=300/400/600$ 检查截断误差。验证 Put 左端 $u(0,T)=K{e}^{-rT}$ 。

运行结果： N_x=401, N_t=400 时，Call pdePrice=8.8268960987，解析值 8.8273212254，相对误差 4.8160e-05；Put 绝对误差 4.248859e-04，Put–Call parity residual 2.406850e-07。

欧式 Put 与 Put–Call Parity

上方工厂已经提供 Put 分支。如需核对 Put 结果，可以同时报告解析误差和 Put–Call parity residual；Put 左端必须使用随剩余期限折现的 K*exp(-r*tau)，不能沿用美式 Put 的常数边界。

产品与假设。美式看跌允许在到期之前的任意时刻行权。对于 r>0,q=0 的标准例，提前行权可能有价值。

数学关系。 $u\ge g$ ，其中 $g=(K-S{)}^{+}$ 。令 $\mathcal{L}u=\frac{1}{2}{\sigma }^2{S}^2{u}_{SS}+rS{u}_S-ru$ ，剩余期限方向满足互补条件 $u-g\ge 0、u_{\tau }-\mathcal{L}u\ge 0、(u-g)(u_{\tau }-\mathcal{L}u)=0$ 。这不是一个只靠左右边界能实现的约束。

边界。在 S=0 处即时行权使价格为 K（本例无分红且 r>0），远端近似为 0。method["obstacle"] 表达内点不等式；PSOR 与 penalty 为两条可选路径。

DolphinDB 完整示例

spot = 100.0
strike = 100.0
rate = 0.05
volatility = 0.20
finalTime = 1.0
spotMax = 300.0
spotGrid = pdeGrid1D(0.0, spotMax, 401, "sinh", strike, 3.0)
tGrid = (0..400) / 400.0

def makeAmericanPutCase(volatility, rate, strike, spotMax) {
    coeff = pdeCoeff1D(
        diff={S,tau -> 0.5 * volatility * volatility * S * S},
        conv={S,tau -> rate * S},
        react=-rate
    )
    payoff = {S -> max(strike-S, 0.0)}
    boundary = [strike, 0.0]
    return coeff, payoff, boundary
}

coeff, payoff, boundary = makeAmericanPutCase(volatility, rate, strike, spotMax)
method = dict(STRING, ANY)
method["rannacherSteps"] = 2
method["obstacle"] = payoff
method["obstacleSolver"] = "PSOR"
method["psorOmega"] = 1.2
method["psorTolerance"] = 1e-10
method["psorMaxIterations"] = 20000

setting = dict(STRING, ANY)
setting["resultMode"] = "detail"
setting["diagnostics"] = true
setting["interpAt"] = spot

result = pdeSolver(
    coeff, payoff, pdeDomain1D(spotGrid), tGrid,
    boundary, method, setting
)
payoffVector = max(strike - spotGrid, 0.0)
obstacleViolation = max(0.0, max(payoffVector - result["value"]))
summary = dict(STRING, ANY)
summary["price"] = result["interpValue"]
summary["obstacleViolation"] = obstacleViolation
summary["iterations"] = result["diagnostics"]["iterations"]["total"]
summary

Penalty 配置要点

Penalty 与上面的 PSOR 示例共用系数、payoff、网格和边界，但必须新建参数字典，不能把 PSOR 字段留在同一个 method 中：

penaltyMethod = dict(STRING, ANY)
penaltyMethod["scheme"] = "implicit"
penaltyMethod["obstacle"] = payoff
penaltyMethod["obstacleSolver"] = "penalty"
penaltyMethod["penaltyFactor"] = 1e8
penaltyMethod["penaltyTolerance"] = 1e-8
penaltyMethod["penaltyMaxIterations"] = 100
penaltyTGrid = (0..200) / 200.0
penaltyResult = pdeSolver(
    coeff, payoff, pdeDomain1D(spotGrid), penaltyTGrid,
    boundary, penaltyMethod, setting
)
summary = dict(STRING, ANY)
summary["price"] = penaltyResult["interpValue"]
summary["linearSolver"] = penaltyResult["meta"]["linearSolver"]
summary["finalResidual"] = penaltyResult["diagnostics"]["iterations"]["finalResidual"]
summary

如需比较 PSOR 与 Penalty，可同时记录价格、最终残差和网格变化；本文示例不构成完整 obstacle 验收。

独立基准： 如需进一步核对，可使用 2000、4000、8000 步 CRR 二叉树或外部美式定价器。本文不提供完整独立基准结论。

执行验收： (1) $P_{Am}\ge P_{Eu}$ ；(2) 所有网格点 $u\ge g-\epsilon$ ；(3) PSOR 容差及步数变化结果稳定；(4) Penalty 因子加倍不产生不合理震荡；(5) 核对每个时间层的迭代残差及非收敛告警。

运行结果： PSOR 返回 price=6.0901245592、obstacleViolation=0、总迭代次数 17341；Penalty 返回 price=6.0833080913、finalResidual=2.5560e-12。

产品与假设。欧式看涨，局部波动率依赖 S 和 $\tau$ 。PDE 的结构保持一维，但二阶系数成为 $A(S,\tau )=\frac{1}{2}{\sigma }_{loc}^2(S,\tau )S^2$ 。

接口映射。函数型 diff 实现模型面，conv=(r-q)S，react=-r；时间片与全量预计算只改变计算策略，不改变数学方程。

DolphinDB 完整示例

spot = 100.0
strike = 100.0
rate = 0.03
dividend = 0.01
volatility = 0.20
spotMax = 400.0
spots = 80.0 100.0 120.0

def makeLocalVolCase(volatility, rate, dividend, strike, spotMax) {
    coeff = pdeCoeff1D(
        diff={S,tau -> 0.5 * (volatility * (1.0 + 0.20*tanh((S-strike)/strike)) * (1.0 + 0.10*tau)) * (volatility * (1.0 + 0.20*tanh((S-strike)/strike)) * (1.0 + 0.10*tau)) * S * S},
        conv={S,tau -> (rate-dividend)*S},
        react=-rate
    )
    payoff = {S -> max(S-strike, 0.0)}
    boundary = [
        {tau -> 0.0},
        {tau -> spotMax*exp(-dividend*tau) - strike*exp(-rate*tau)}
    ]
    return coeff, payoff, boundary
}
coeff, payoff, boundary = makeLocalVolCase(volatility, rate, dividend, strike, spotMax)

coarseGrid = pdeGrid1D(0.0, spotMax, 201, "sinh", strike, 3.0)
mediumGrid = pdeGrid1D(0.0, spotMax, 301, "sinh", strike, 3.0)
coarseMethod = dict(STRING, ANY)
coarseMethod["precompute"] = "all"
mediumAllMethod = dict(STRING, ANY)
mediumAllMethod["precompute"] = "all"
mediumSliceMethod = dict(STRING, ANY)
mediumSliceMethod["precompute"] = "timeSlice"
coarseSetting = dict(STRING, ANY)
coarseSetting["resultMode"] = "detail"
coarseSetting["interpAt"] = spots
mediumAllSetting = dict(STRING, ANY)
mediumAllSetting["resultMode"] = "detail"
mediumAllSetting["interpAt"] = spots
mediumSliceSetting = dict(STRING, ANY)
mediumSliceSetting["resultMode"] = "detail"
mediumSliceSetting["interpAt"] = spots

coarse = pdeSolver(coeff, payoff, pdeDomain1D(coarseGrid), (0..100) / 100.0, boundary, coarseMethod, coarseSetting)
mediumAll = pdeSolver(coeff, payoff, pdeDomain1D(mediumGrid), (0..150) / 150.0, boundary, mediumAllMethod, mediumAllSetting)
mediumSlice = pdeSolver(coeff, payoff, pdeDomain1D(mediumGrid), (0..150) / 150.0, boundary, mediumSliceMethod, mediumSliceSetting)
precomputeDifference = max(abs(mediumAll["interpValue"] - mediumSlice["interpValue"]))
summary = dict(STRING, ANY)
summary["coarsePrice"] = coarse["interpValue"]
summary["mediumPrice"] = mediumAll["interpValue"]
summary["precomputeDifference"] = precomputeDifference
summary["precomputeModeAll"] = mediumAll["meta"]["precomputeMode"]
summary["precomputeModeTimeSlice"] = mediumSlice["meta"]["precomputeMode"]
summary

独立基准： 同一模型的更细空间/时间网格解；若有独立 local-vol 实现，则以相同局部波动率函数对照。

可选结果核对： 可以比较 precompute=all 与 timeSlice 的结果，并观察空间、时间步长和 Smax 的影响。

运行结果： 粗网格三个插值点的价格为 (1.53592973, 9.22061441, 23.88065593)，中网格为 (1.53651947, 9.22152872, 23.88069652)。

产品与假设。现金或无看涨数字期权，payoff 为 $C{\mathbf{1}}_{\{S_T>K\}}$ ，在 K 处不连续。

模型与处理。Black–Scholes PDE 不变，initial 在阈值处跳跃；优先用 Rannacher smoothing，并在 strike 附近聚焦网格。此举控制短期高频振荡，但不等于精度自动达标。

DolphinDB 最小调用片段

Digital 与 Vanilla 的 PDE 相同，主要替换不连续 payoff、边界和初始 Rannacher 设置。下面的函数可独立运行：

def runDigitalCase(spot, strike, rate, dividend, vol, maturity, spotMax) {
    payout = 1.0
    coeff = pdeCoeff1D(
        diff={S,tau -> 0.5 * vol * vol * S * S},
        conv={S,tau -> (rate-dividend) * S},
        react=-rate
    )
    payoff = {S -> iif(S > strike, payout, 0.0)}
    boundary = [{tau -> 0.0}, {tau -> payout*exp(-rate*tau)}]
    spotGrid = pdeGrid1D(0.0, spotMax, 401, "sinh", strike, 3.0)
    tGrid = (0..200) / 200.0
    method = dict(STRING, ANY)
    method["theta"] = 0.5
    method["rannacherSteps"] = 2
    setting = dict(STRING, ANY)
    setting["resultMode"] = "detail"
    setting["interpAt"] = spot
    result = pdeSolver(coeff, payoff, pdeDomain1D(spotGrid), tGrid, boundary, method, setting)
    d1 = (log(spot/strike) + (rate-dividend+0.5*vol*vol)*maturity) / (vol*sqrt(maturity))
    d2 = d1 - vol*sqrt(maturity)
    reference = payout * exp(-rate*maturity) * cdfNormal(0.0, 1.0, d2)
    summary = dict(STRING, ANY)
    summary["price"] = result["interpValue"]
    summary["closedFormPrice"] = reference
    summary["absoluteError"] = abs(result["interpValue"] - reference)
    return summary
}
runDigitalCase(100.0, 100.0, 0.03, 0.01, 0.20, 1.0, 400.0)

完整可运行脚本和解析参考计算见案例包；重点是检查 strike 附近振荡和 Greeks 对网格的敏感性。

解析基准（单位现金支付）： $C{e}^{-rT}N(d_2)$ 。取 $C=1,S_0=K=100,r=3\%,q=1\%,\sigma =20\%,T=1$ 时，参考值 0.48522277。脚本参数若与该组不同，必须重新计算解析值。

可选结果核对： 可以比较 rannacherSteps=0/1/2，并观察 strike 附近振荡及网格敏感性。

运行结果： N_x=401, N_t=200 时，价格为 0.4823201116，解析值为 0.4852227668，绝对误差 0.0029026552；数值范围为 [0.0, 0.9704455396]。

产品与假设。连续观察且无返还的 Knock-Out 期权。触碰障碍后价值变成 0，所以障碍位置对应吸收边界。单障碍情形把障碍本身作为定义域端点；双障碍把整个求解域限制在两个障碍之间。

边界模型。下敲出 $u(B_{down},\tau )=0$ ，上敲出 $u(B_{up},\tau )=0$ 。对于未触及障碍的终值 $g(S)$ ，在障碍上需要令 $g(B)=0$ ；若 payoff 在边界并非零，应检查初始兼容性并按合同正确解释到期触碰条款。

DolphinDB 最小示例：下敲出

spot = 100.0
strike = 100.0
barrier = 80.0
rate = 0.03
dividend = 0.01
volatility = 0.20
finalTime = 1.0
spotMax = 400.0
def makeDownOutCallCase(volatility, rate, dividend, strike, barrier, spotMax) {
    coeff = pdeCoeff1D(
        diff={S,tau -> 0.5 * volatility * volatility * S * S},
        conv={S,tau -> (rate-dividend) * S},
        react=-rate
    )
    payoff = {S -> max(S-strike, 0.0)}
    boundary = [
        0.0,
        {tau -> spotMax*exp(-dividend*tau) - strike*exp(-rate*tau)}
    ]
    return coeff, payoff, boundary
}
coeff, payoff, boundary = makeDownOutCallCase(volatility, rate, dividend, strike, barrier, spotMax)
spotGrid = pdeGrid1D(barrier, spotMax, 401, "sinh", strike, 3.0)
tGrid = (0..400) / 400.0
method = dict(STRING, ANY)
method["rannacherSteps"] = 2
setting = dict(STRING, ANY)
setting["resultMode"] = "detail"
setting["interpAt"] = spot
result = pdeSolver(coeff, payoff, pdeDomain1D(spotGrid), tGrid, boundary, method, setting)
summary = dict(STRING, ANY)
summary["price"] = result["interpValue"]
summary["barrierValue"] = result["value"][0]
summary["minValue"] = min(result["value"])
summary

其他障碍类型的映射

单敲出与双敲出的代码结构相同，差异只在定义域和两端边界：

因此，先用上面的 Down-and-Out 最小示例跑通，再按表格替换 domain、payoff 和 boundary；完整三种脚本保留在案例包中。

独立基准： 单障碍可用满足一致连续观察条款的解析屏障定价公式；双障碍可用高精度独立 PDE 或谱展开参考。

可选结果核对： 可以检查障碍边界、价格非负性以及网格和截断域敏感性。

运行结果： 下敲出看涨价格 8.7309347961，上敲出看涨价格 3.0969185841，双敲出看涨价格 3.0964585436；各示例障碍端点值均为 0.0。

产品与假设。标的首次触及上障碍时触发给付。必须明确合同支付时点：触碰即付（Pay at Hit）或触碰确认后到期才付（Pay at Maturity）。两者可使用相同生存域，但碰触边界不同。

边界。触碰即付： $u(B,\tau )=C$ ；到期支付： $u(B,\tau )=C{e}^{-r\tau }$ 。若 $S_0<B$ 且未触及，初值在域内为 0。

DolphinDB 最小调用片段

One Touch 的核心不是新 PDE，而是触碰支付时点对应的障碍边界。下面以 Pay at Maturity 为例，并保留 payAtHit 切换：

def runOneTouchCase(spot, barrier, rate, dividend, vol, payout, maturity, payAtHit) {
    coeff = pdeCoeff1D(
        diff={S,tau -> 0.5 * vol * vol * S * S},
        conv={S,tau -> (rate-dividend) * S},
        react=-rate
    )
    payoff = {S -> iif(S >= barrier, payout, 0.0)}
    if (payAtHit) {
        boundary = [0.0, payout]
    } else {
        boundary = [0.0, {tau -> payout * exp(-rate*tau)}]
    }
    spotGrid = pdeGrid1D(0.0, barrier, 401, "sinh", spot, 3.0)
    tGrid = (0..200) / 200.0
    method = dict(STRING, ANY)
    method["rannacherSteps"] = 2
    setting = dict(STRING, ANY)
    setting["resultMode"] = "detail"
    setting["interpAt"] = spot
    result = pdeSolver(coeff, payoff, pdeDomain1D(spotGrid), tGrid, boundary, method, setting)
    summary = dict(STRING, ANY)
    summary["price"] = result["interpValue"]
    summary["barrierValue"] = result["value"][size(result["value"]) - 1]
    return summary
}
runOneTouchCase(100.0, 130.0, 0.03, 0.01, 0.20, 1.0, 1.0, false)

将对应的 boundary 传给同一 pdeSolver 调用即可。完整函数和 Pay at Maturity 运行结果见案例包。

独立基准： 采用 GBM 首达时间的解析概率/折现首达时间期望，或带 Brownian bridge 监测修正的独立 MC。

可选结果核对：可以检查非负性、价格范围、Pay at Hit 与 Pay at Maturity 的差异，以及是否已触碰障碍。

运行结果： 当前代码是 Pay at Maturity，价格 0.1839887388，障碍端值 0.9704455335。

产品与假设。连续算术平均固定执行价看涨： $\Phi =(A_T/T-K{)}^{+}$ ， $A_t={\int }_0^t{S}_{s}ds$ 是累计积分，单位为价格×时间，不是已实现平均值。

原始二维 PDE。对 $V(t,S,A)$ 有 $V_t+\frac{1}{2}{\sigma }^2{S}^2{V}_{SS}+(r-q)S{V}_S+S{V}_A-rV=0$ 。

令 $x=\frac{A-KT}{S}，V=\frac{S}{T}v(x,\tau )$ ，可推得

$v_{\tau }=\frac{1}{2}{\sigma }^2{x}^2{v}_{xx}+[1-(r-q)x]v_x-qv,v(x,0)=x^{+}$

本案例采用 q=0；当 $x\to +\infty$ 时，解在右侧区域近似线性，其斜率满足 $v_x\to e^{-r\tau }$ ，因此右端可以采用 Neumann 边界近似。合约起点定价时 $A_0=0$ ，故示例 $S_0=K=100,T=1$ 对应 $x_0=-1$ 。

DolphinDB 完整示例

spot = 100.0
strike = 100.0
rate = 0.03
volatility = 0.20
finalTime = 1.0

def makeAsianCase(volatility, rate, xMin, xMax) {
    coeff = pdeCoeff1D(
        diff={x,tau -> 0.5*volatility*volatility*x*x},
        conv={x,tau -> 1.0-rate*x}
    )
    payoff = {x -> max(x,0.0)}
    rightGradient = dict(STRING, ANY)
    rightGradient["type"] = "neumann"
    rightGradient["value"] = {tau -> exp(-rate*tau)}
    boundary = [0.0, rightGradient]
    return coeff, payoff, boundary
}

accumulatedIntegral = 0.0  // A_0 = integral_0^0 S_u du = 0
coeff, payoff, boundary = makeAsianCase(volatility, rate, -6.0, 8.0)
xGrid = pdeGrid1D(-6.0, 8.0, 401, "sinh", 0.0, 3.0)
tGrid = (0..400) * finalTime / 400.0
method = dict(STRING, ANY)
setting = dict(STRING, ANY)
setting["resultMode"] = "value"
x0 = (accumulatedIntegral-strike*finalTime) / spot
setting["interpAt"] = x0
result = pdeSolver(coeff, payoff, pdeDomain1D(xGrid), tGrid, boundary, method, setting)
price = spot/finalTime * result["interpValue"]
summary = dict(STRING, ANY)
summary["price"] = price
summary["transformedCoordinate"] = x0
summary["gridSize"] = size(xGrid)
summary

独立基准： 连续路径 MC，采用与 PDE 相同的积分归一化 $\frac{A_T}{T}$ ；离散求和需报告监测步长的离散化偏差。

如需进一步验证，可使用 Monte Carlo 对照，并报告路径数、时间离散方式和标准误。本文示例不提供完整 MC 验收结论。

运行结果： x_0=-1.0、网格大小为 401 时，价格为 5.2742743038。

产品与假设。Heston 方差过程 $dv=\kappa (\theta -v)dt+\xi \sqrt{v}d{W}^v$ ，标的 $dS=rSdt+\sqrt{v}Sd{W}^S$ ， $d{W}^{S}d{W}^v=\rho dt$ 。令 $x=\ln S$ ，得到

$u_{\tau }=\frac{1}{2}v{u}_{xx}+\frac{1}{2}{\xi }^{2}v{u}_{vv}+\rho \xi v{u}_{xv}+(r-\frac{1}{2}v)u_x+\kappa (\theta -v)u_v-ru$

边界选择。x 方向低端近零价、高端近线性价；v=0 为退化边界，简单 Neumann=0 是数值近似，不等于一般模型解析边界；应扫描 $v_{max}$ 、近零网格和替代边界约定。Feller 条件 $2\kappa \theta \ge {\xi }^2$ 属于过程性质，不是 API 强制约束。

DolphinDB 完整示例

rate = 0.05
theta = 0.04
kappa = 2.0
sigmaV = 0.30
rho = -0.70
spot = 100.0
strike = 100.0
finalTime = 1.0
spotMax = 2000.0
vMax = 1.0

def makeHestonCase(rate, theta, kappa, sigmaV, rho, strike, xMax) {
    coeff = pdeCoeff2D(
        xx={x,v,tau -> 0.5*v},
        yy={x,v,tau -> 0.5*sigmaV*sigmaV*v},
        xy={x,v,tau -> rho*sigmaV*v},
        x={x,v,tau -> rate-0.5*v},
        y={x,v,tau -> kappa*(theta-v)},
        u=-rate
    )
    payoff = {x,v -> max(exp(x)-strike, 0.0)}
    varianceBoundary = dict(STRING, ANY)
    varianceBoundary["type"] = "neumann"
    varianceBoundary["value"] = 0.0
    boundary = [
        0.0,
        {v,tau -> exp(xMax) - strike*exp(-rate*tau)},
        varianceBoundary,
        varianceBoundary
    ]
    return coeff, payoff, boundary
}

logGrid = (0..120) * ((log(spotMax) - log(1.0)) / 120.0) + log(1.0)
varianceUnit = (0..60) / 60.0
varianceGrid = varianceUnit * varianceUnit
coeff, payoff, boundary = makeHestonCase(rate, theta, kappa, sigmaV, rho, strike, log(spotMax))
tGrid = (0..120) * (finalTime / 120.0)
method = dict(STRING, ANY)
method["adiScheme"] = "MCS"
method["parallel"] = false
method["rannacherSteps"] = 2
method["precompute"] = "timeSlice"
setting = dict(STRING, ANY)
setting["resultMode"] = "detail"
setting["diagnostics"] = true
setting["interpAt"] = [log(spot), 0.04]
result = pdeSolver(coeff, payoff, pdeDomain2D(logGrid, varianceGrid), tGrid, boundary, method, setting)
summary = dict(STRING, ANY)
summary["price"] = result["interpValue"]
summary["adiScheme"] = result["meta"]["adiScheme"]
summary["success"] = result["diagnostics"]["success"]
summary

独立基准： 优先使用 Heston 半解析特征函数积分定价、经验证的外部 pricer 或高精度 Fourier 定价实现。测得 QuantLib AnalyticHestonEngine 的半解析结果为 10.3942185652。

可选结果核对：可以核对混合导数系数，并观察空间、方差和时间网格以及截断域变化的影响。

运行结果： 121×61 空间网格、120 个时间区间、MCS 下，价格为 10.4614959124，diagnostics.success=true。

产品与假设。两资产加权篮子 $\Phi (S_1,S_2)=(w_1{S}_1+w_2{S}_2-K{)}^{+}$ 。在零股息情形下，二维 xy=rho*sigma1*sigma2*S1*S2。

关键边界纠错。在 $S_1=0$ 时， $S_2$ 仍服从扩散过程，该边界上的价值是 $w_2\times BSCall(S_2,K/w_2)$ ，不能直接用 $max(w_2{S}_2-K{e}^{-r\tau },0)$ 代替。在 $S_2=0$ 时对称处理。两个高价格端使用远端 Delta 的 Neumann 渐近条件，避免给出相互冲突的角点 Dirichlet 值。

DolphinDB 最小可运行示例

Basket 的关键不是重复二维求解器调用，而是交叉项、退化边界和高端 Neumann 边界。下面保留一维辅助边界和最小二维求解：

def oneAssetCall(S, K, r, sigma, tau) {
    if (S <= 0.0) return 0.0
    if (tau <= 0.0) return max(S-K, 0.0)
    d1 = (log(S/K) + (r+0.5*sigma*sigma)*tau) / (sigma*sqrt(tau))
    d2 = d1 - sigma*sqrt(tau)
    return S*cdfNormal(0.0,1.0,d1) - K*exp(-r*tau)*cdfNormal(0.0,1.0,d2)
}
def runBasketCase() {
    spot1=100.0; spot2=100.0; strike=100.0; rate=0.03
    sigma1=0.20; sigma2=0.30; rho=0.25; w1=0.5; w2=0.5
    coeff = pdeCoeff2D(
        xx={S1,S2,tau -> 0.5*sigma1*sigma1*S1*S1},
        yy={S1,S2,tau -> 0.5*sigma2*sigma2*S2*S2},
        xy={S1,S2,tau -> rho*sigma1*sigma2*S1*S2},
        x={S1,S2,tau -> rate*S1}, y={S1,S2,tau -> rate*S2}, u=-rate
    )
    payoff = {S1,S2 -> max(w1*S1+w2*S2-strike,0.0)}
    xHigh=dict(STRING,ANY); xHigh["type"]="neumann"; xHigh["value"]={S2,tau -> w1}
    yHigh=dict(STRING,ANY); yHigh["type"]="neumann"; yHigh["value"]={S1,tau -> w2}
    boundary = [
        {S2,tau -> w2*oneAssetCall(S2,strike/w2,rate,sigma2,tau)}, xHigh,
        {S1,tau -> w1*oneAssetCall(S1,strike/w1,rate,sigma1,tau)}, yHigh
    ]
    xGrid=(0..80)*5.0; yGrid=xGrid; tGrid=(0..120)/120.0
    method=dict(STRING,ANY); method["adiScheme"]="MCS"; method["parallel"]=false
    setting=dict(STRING,ANY); setting["resultMode"]="detail"; setting["diagnostics"]=true; setting["interpAt"]=[spot1,spot2]
    result=pdeSolver(coeff,payoff,pdeDomain2D(xGrid,yGrid),tGrid,boundary,method,setting)
    summary=dict(STRING,ANY); summary["price"]=result["interpValue"]; summary["success"]=result["diagnostics"]["success"]
    return summary
}
runBasketCase()

边界顺序仍为 [xMin,xMax,yMin,yMax]；两个低端边界使用一维 BS 看涨价格，高端使用 Neumann 条件。

独立基准： 独立多资产 Monte Carlo，相关正态增量 $Z_2=\rho Z_1+\sqrt{1-{\rho }^2}{Z}_{ind}$ ，给出路径数、时间离散（若需要）和标准误。

可选结果核对： 可以检查退化边界、价格非负性、相关性变化和两个空间截断边界的影响。

运行结果： 81×81 空间网格、120 个时间区间、MCS 下，价格为 9.3986919796，diagnostics.success=true。

考虑零成本交换权，收益为 $(S_{1,T}-S_{2,T}{)}^{+}$ 。两标的在同一风险中性测度下分别服从相关 GBM，连续股息率为 $q_1,q_2$ ，波动率为 ${\sigma }_1,{\sigma }_2$ ，瞬时相关系数为 $\rho$ 。令 $x=\ln S_1,y=\ln S_2$ ，两维 PDE 的混合导数完整系数为 $\rho {\sigma }_1{\sigma }_2$ 。

Margrabe 解析解：

${\sigma }_M=\sqrt{{\sigma }_1^2+{\sigma }_2^2-2\rho {\sigma }_1{\sigma }_2},C_M=S_1{e}^{-q_1\tau }N(d_1)-S_2{e}^{-q_2\tau }N(d_2),$

$d_1=\frac{\ln (S_1/S_2)+(q_2-q_1+\frac{1}{2}{\sigma }_M^2)\tau }{{\sigma }_M\sqrt{\tau }},d_2=d_1-{\sigma }_M\sqrt{\tau }.$

当 $\tau =0$ ，直接返回 payoff，以避免除以零。假设正的标的价格、正的合成波动率。二维空间截断取 $S_1,S_2\in [S_{min},S_{max}]$ ；四条边界按当前边上的两个标的值使用同一 Margrabe 公式，同时满足角点一致性。

DolphinDB 最小可运行示例

Exchange 使用 log-price 坐标，并把同一个 Margrabe 公式用于四条边界：

def margrabeBoundary(s1, s2, tau, vol1, vol2, corr, q1, q2) {
    if (tau <= 0.0) return max(s1-s2, 0.0)
    volM=sqrt(vol1*vol1+vol2*vol2-2.0*corr*vol1*vol2)
    d1=(log(s1/s2)+(q2-q1+0.5*volM*volM)*tau)/(volM*sqrt(tau))
    d2=d1-volM*sqrt(tau)
    return s1*exp(-q1*tau)*cdfNormal(0.0,1.0,d1)-s2*exp(-q2*tau)*cdfNormal(0.0,1.0,d2)
}
def runExchangeCase() {
    asset1=100.0; asset2=100.0; rate=0.03; sigma1=0.20; sigma2=0.30; rho=0.25
    q1=0.0; q2=0.0; sMin=1.0; sMax=2000.0; maturity=1.0
    coeff=pdeCoeff2D(xx=0.5*sigma1*sigma1, yy=0.5*sigma2*sigma2, xy=rho*sigma1*sigma2,
        x=rate-q1-0.5*sigma1*sigma1, y=rate-q2-0.5*sigma2*sigma2, u=-rate)
    payoff={x,y -> max(exp(x)-exp(y),0.0)}
    xGrid=(0..600)*(log(sMax/sMin)/600.0)+log(sMin); yGrid=xGrid; tGrid=(0..120)/120.0
    boundary=[
        {y,tau -> margrabeBoundary(exp(xGrid[0]),exp(y),tau,sigma1,sigma2,rho,q1,q2)},
        {y,tau -> margrabeBoundary(exp(xGrid[size(xGrid)-1]),exp(y),tau,sigma1,sigma2,rho,q1,q2)},
        {x,tau -> margrabeBoundary(exp(x),exp(yGrid[0]),tau,sigma1,sigma2,rho,q1,q2)},
        {x,tau -> margrabeBoundary(exp(x),exp(yGrid[size(yGrid)-1]),tau,sigma1,sigma2,rho,q1,q2)}
    ]
    method=dict(STRING,ANY); method["adiScheme"]="MCS"; method["rannacherSteps"]=2
    setting=dict(STRING,ANY); setting["resultMode"]="detail"; setting["diagnostics"]=true; setting["interpAt"]=[log(asset1),log(asset2)]
    result=pdeSolver(coeff,payoff,pdeDomain2D(xGrid,yGrid),tGrid,boundary,method,setting)
    reference=margrabeBoundary(asset1,asset2,maturity,sigma1,sigma2,rho,q1,q2)
    summary=dict(STRING,ANY); summary["pdePrice"]=result["interpValue"]; summary["margrabeReference"]=reference; summary["absoluteError"]=abs(result["interpValue"]-reference)
    return summary
}
runExchangeCase()

四个边界函数都调用同一个 margrabeBoundary，并使用当前边上的两个标的值。

运行结果为 12.5667783189，Margrabe 解析值为 12.5632938837，绝对误差为 0.0034844352。若需要更严格的价格误差，应继续细化二维空间、时间网格并扩大截断域。

对半离散系统 $U_{\tau }=L_{h}U$ ，Theta 格式满足：

$(I-\theta \Delta \tau L_h)U^{n+1}=(I+(1-\theta )\Delta \tau L_h)U^n$

• $\theta =0$ ：显式，稳定性限制严，在非均匀网格最小间距处尤需小心。

• $\theta =1$ ：隐式 Euler，一阶时间精度，单调性一般更稳定。

• $\theta =0.5$ ：Crank–Nicolson，在足够光滑解下通常二阶时间精度，但不连续 payoff 附近可能产生短暂振荡。

pdeSolver 的具体 scheme/theta 可用组合和合法参数请见第 3 章官方文档。

对 Digital 或 Call/Put 的不光滑 payoff，初期若干时间区间使用隐式半步，有助于抑制 Crank–Nicolson 在初值附近的振荡。rannacherSteps 指的是公开时间区间数，不是需要额外增加到 tGrid 的独立时间点。比较 0/1/2 必须固定其他参数。

美式期权是离散互补问题。选 PSOR 时记录 omega/tolerance/maxIterations、最终约束违反量和迭代统计；选 penalty 时记录惩罚因子、停止容差及偏离 obstacle 的量。两组求解器的专有参数不得混用。对于非收敛不应以“最后一次迭代价格”代替已验证价格。

Douglas、CS、MCS、HV 各有稳定性与截断误差特征。具有混合导数的 Heston/Basket/Exchange，优先从官方默认 MCS 入手，再扫描 adiTheta 与空间、时间网格；没有统一对全部参数都最优的方案。二维完整隐式与二维 obstacle 当前不在接口范围内。

对于执行价附近弯折，使用 sinh 聚焦；障碍产品同时关注障碍边界附近；Heston 方差维度在低方差区加密。聚焦网格是重分配节点，不保证任意指标自动提升。单独扩大 $S_{max}$ 、 $v_{max}$ 或 log 坐标范围，是严肃定价验证的必需步骤。

• 默认 resultMode="value" 且没有插值/Greeks 请求：直接返回数值数组。

• 有 interpAt 或 calcGreeks=true 时：即便 resultMode="value"，也可能返回包含 interpValue、greeks 的字典。

• resultMode="detail" 返回字典；diagnostics=true 仅与该模式配合。默认输出是最终时间层，可用 output="all"/"selected" 修改。

对 S 坐标, $Delta=u_S$ 、 $Gamma=u_{SS}$ ；对二维价格坐标，获取 ${\partial }_{S_1}u、{\partial }_{S_2}u$ 和混合 Gamma。不要将全部二维 Greek 直接称为 Vega：如果第二坐标是方差 $v，u_v$ 对应 variance sensitivity，转换成对波动率 $\sqrt{v}$ 的 Vega 还需要 $2\sqrt{v}$ 因子（对于 $v>0$ ）。

若 $x=\ln S$ ，对 S 的价格 Delta/Gamma 为

$\Delta =\frac{u_x}{S}$ , $\Gamma =\frac{u_{xx}-u_x}{S^2}$

pdeSolver 输出的 Greek 是相对于其计算坐标的导数；在 Heston、Exchange 的 log 坐标模型中，金融 Greek 必须经坐标转换才有业务意义。

时间网格沿剩余期限 $\tau$ 正向计算；标准日历 Theta 定义为在其他变量不变时 $\partial V/\partial t=-\partial u/\partial \tau$ 。在文档和测试中必须区分“期限方向导数”和“日历日时间流逝的敏感度”。

采用 Spot 上下扰动 h 的中心差分，

${\Delta }_h=\frac{V(S+h)-V(S-h)}{2h},{\Gamma }_h=\frac{V(S+h)-2V(S)+V(S-h)}{h^2}.$

至少扫描三个 h，注意过小的 h 会放大数值噪声。对 Digital、Barrier、American 早行权边界附近 Greeks，可出现不光滑或局部不稳定，应单独解释而不是用一个全球容差掩盖。

pdeSolver 已经封装了网格、PDE 系数、边界条件、时间推进和求解过程。使用时，用户主要需要说明三个问题：产品的收益如何计算、模型参数是什么、价格在边界上如何变化。有限差分离散、矩阵组装和线性方程求解等通用工作由 pdeSolver 完成。

典型流程比较固定：

构建网格 → 定义区域 → 设置 PDE 系数 → 设置 payoff 和边界
→ 选择求解方法 → 调用 pdeSolver → 读取价格和诊断

同一套流程可以用于欧式期权、American 期权、Barrier、Digital、Asian、Quanto、Local Volatility 以及部分二维模型。更换产品时，通常只需调整 payoff、系数或边界条件，不需要重新实现整个求解器。

这里的“简洁”不只是代码行数少，更重要的是业务逻辑和数值算法分开了。对于需要维护多个定价模型的团队，这可以减少重复代码，也方便后续修改、排查和复现。

pdeSolver 将模型描述和数值求解分开。网格、定义域、系数、边界、障碍条件和输出设置分别配置，产品逻辑不会和底层求解过程混在一起。

目前教程中的案例覆盖了几类常见场景：

• 标准期权：European Call、European Put、Digital；

• 带边界或路径特征的产品：Barrier、One Touch、Asian、Quanto；

• 更复杂的模型：Local Volatility、Heston、Basket、Exchange。

这些产品的金融含义不同，但可以使用相近的网格、系数、边界和求解流程。以 European Put 和 American Put 为例，两者可以共享大部分 PDE 设置，American Put 只需要增加早行权约束，并选择 PSOR 或 Penalty 方法。

对业务人员来说，这意味着新增产品时不必从零开始开发。已有案例可以作为模板，重点修改 payoff、参数和边界条件。

pdeSolver 提供多种时间推进和二维求解方法，包括 Explicit、Implicit Euler、Crank–Nicolson、Theta、Douglas、CS、MCS 和 HV 等方法，同时支持 PSOR、Penalty、非均匀网格和 Rannacher smoothing。

不同产品遇到的计算问题并不一样，因此可以按产品特点选择方法：

因此，复杂产品通常可以通过调整系数、边界和求解设置来实现，而不是为每个产品单独开发一套数值程序。最终方法仍需要结合网格收敛和参考结果进行确认。

pdeSolver 不只返回一个价格，还可以根据配置输出插值价格、详细结果、Delta、Gamma、Mixed Gamma、诊断信息以及部分执行路径信息。

一次计算可以同时回答三个问题：

• 价格是多少：获取指定标的和参数下的定价结果；

• 风险如何变化：获取 Delta、Gamma 等 Greeks；

• 这次计算是否正常：查看收敛、迭代和其他诊断信息。

对于 Digital、Barrier 和 American 等数值上不够光滑的产品，诊断信息有助于发现网格、边界、迭代或收敛方面的问题。这样，业务结果和技术状态可以一起记录，而不是只保存一个价格。

需要注意，diagnostics.success=true 只能说明求解过程成功返回，不能代替独立的精度验证。

多个定价案例可以在 DolphinDB 服务端集中执行。这样可以减少客户端与服务端之间的重复请求，也便于统一记录模型参数、网格设置、求解方法和诊断结果。

单个产品定价时，客户端发起一次请求即可；当需要同时计算多个产品、多个期限或多个参数组合时，可以把任务集中提交给服务端。本文示例中，16 个案例通过一次服务端请求完成，而逐案例调用需要发起 16 次请求。

批量执行的主要价值是减少客户端编排和通信管理，同时集中保存每个案例的参数、价格和诊断信息。实际耗时仍取决于网络、并发量、任务规模和部署方式。

pdeSolver 可以结合向量化计算、precompute="all"、precompute="timeSlice"、JIT 和低延迟执行路径进行优化。简单来说，就是尽量减少重复计算，并让适合向量化的计算一次处理一批数据。

不同路径适用于不同类型的系数和工作流：

• 系数不随时间变化时，可以考虑预计算；

• 系数随时间变化时，可以使用 timeSlice；

• 批量计算时，可以将多个案例放在服务端统一执行；

• 对适合的表达式，可以尝试 JIT 或向量化路径。

以上性能基于 DolphinDB V3.00.6.4 Linux 版本测试。不同实现的算法、精度、网格和执行路径可能不同，表中数据仅供参考。不同实现可能使用不同算法、网格和精度设置，因此不能据此得出 pdeSolver 在所有场景下都更快的结论。American Put、Heston 等案例仍应结合算法一致性和网格收敛结果一起判断。

本次测试 pdeSolver 相对于 QuantLib 性能提升不明显，原因是 QuantLib 本身是也是 C++ 开发的。pdeSolver 的主要优势是模型表达和复用：从欧式期权扩展到数字期权、障碍期权、局部波动率或 Quanto 时，通常可以沿用求解流程，重点修改 payoff、PDE 系数或边界条件。QuantLib 也可以扩展，但使用现成引擎之外的模型往往需要进一步组合或开发其底层组件，灵活性不够。

由于模型参数、网格、边界和数值方法都可以显式记录，pdeSolver 案例比较适合做以下工作：

• 保存定价配置；

• 对比不同网格和求解方法；

• 扩展新的 payoff；

• 批量运行多个案例；

• 记录价格、Greeks 和诊断结果；

• 在不同 DolphinDB 版本和部署环境中重新测试。

实际使用时，可以先从一个已有案例开始，替换产品参数和 payoff，再逐步增加新的边界条件或风险因子。这样比从空白代码开始实现更容易控制修改范围。

这些优势主要体现在代码复用和工程组织上。具体数值精度和运行性能仍需要结合产品定义、参数、网格、版本和硬件环境单独确认。

每次生产定价至少保存：产品与报价标识、模型版本、定价日、输入参数、domain/coeff/method/setting、DolphinDB 构建版本、价格与 Greeks、诊断告警、基准测试结果或上一次有效的回归版本。

若无法判断属于哪一类，再按下列顺序执行：

1. 先核对 payoff、现金流、货币与期限，再查 PDE 系数符号。

2. 检查 initial 与 Dirichlet 边界在 $\tau =0$ 是否兼容。

3. 检查坐标单位、log 变换、二阶和混合导数系数。

4. 判断网格/时间步/截断域三类数值误差是否互相掩盖。

5. 检查 obstacle 非收敛、ADI 诊断、输出字典结构。

6. 最后才调整 JIT、precompute、内存和并行。