graph TD
    subgraph L1["第1层 基础设施"]
        A1["types.hpp 类型别名"]
        A2["errors.hpp 错误处理"]
        A3["qldefines.hpp 编译配置"]
        A4["shared_ptr.hpp 智能指针"]
    end

    subgraph L2["第2层 设计模式核心"]
        B1["patterns/ Observer-Observable"]
        B2["patterns/ LazyObject"]
        B3["patterns/ Singleton"]
        B4["handle.hpp Handle"]
    end

    subgraph L3["第3层 基础模块"]
        C1["time/ 日期与时间"]
        C2["utilities/ 工具类"]
        C3["math/ 数值算法"]
        C4["currencies/ 货币体系"]
    end

    subgraph L4["第4层 市场数据层"]
        D1["quotes/ 市场报价"]
        D2["termstructures/ 期限结构"]
        D3["indexes/ 指数体系"]
    end

    subgraph L5["第5层 过程与模型层"]
        E1["processes/ 随机过程"]
        E2["models/ 模型参数化"]
    end

    subgraph L6["第6层 数值方法层"]
        F1["finitedifferences/ FD"]
        F2["lattices/ 格点树"]
        F3["montecarlo/ MC"]
    end

    subgraph L7["第7层 工具与引擎层"]
        G1["cashflows/ 现金流"]
        G2["instruments/ 金融工具"]
        G3["pricingengines/ 定价引擎"]
    end

    subgraph L8["第8层 实验与遗留"]
        H1["experimental/ 实验模块"]
        H2["legacy/ 遗留LMM"]
    end

    L2 --> L3
    L3 --> L4
    L3 --> L5
    L4 --> L5
    L4 --> L6
    L5 --> L6
    L5 --> L7
    L6 --> L7
    G1 --> G2
    G2 --> G3
    G3 --> G2
    L7 --> L8

graph LR
    subgraph SRC["数据源"]
        Q["SimpleQuote<br/>市场报价原子单元"]
        F["Fixing<br/>历史定息"]
    end

    subgraph BUILD["曲线构建"]
        BH["BootstrapHelper<br/>报价到误差函数"]
        TS["TermStructure<br/>自举和插值"]
    end

    subgraph CHAIN["估值链"]
        IDX["Index<br/>历史与远期决策"]
        PRO["StochasticProcess<br/>SDE漂移和扩散"]
        MDL["CalibratedModel<br/>参数和校准"]
        ENG["PricingEngine<br/>定价算法"]
        CF["CashFlow<br/>现金流计算"]
        INST["Instrument<br/>NPV and Greeks"]
    end

    subgraph NUM["数值方法"]
        FD["有限差分 PDE"]
        LT["格点与树"]
        MC["蒙特卡洛"]
    end

    Q -->|Observer| BH
    F -->|IndexManager| IDX
    BH -->|Brent求根| TS
    TS -->|Handle| IDX
    TS -->|Handle| PRO
    PRO -->|observer| MDL
    MDL -->|calibrate| ENG
    PRO --> FD
    PRO --> LT
    PRO --> MC
    TS -->|Handle| ENG
    IDX -->|fixing| CF
    CF -->|Leg| INST
    ENG -->|calculate| INST
    FD --> ENG
    LT --> ENG
    MC --> ENG

classDiagram
    class Observable {
        -set~Observer*~ observers_
        +notifyObservers()
        -registerObserver(Observer*)
        -unregisterObserver(Observer*)
    }

    class Observer {
        -set~shared_ptr~Observable~~ observables_
        +registerWith(shared_ptr)
        +unregisterWithAll()
        +update()*
        +deepUpdate()
    }

    class LazyObject {
        -bool calculated_
        -bool frozen_
        -bool failed_
        -bool alwaysForward_
        +calculate()
        +recalculate()
        +freeze() / unfreeze()
        +update()
        #performCalculations()*
    }

    class ObservableSettings {
        -map deferredObservers_
        -bool updatesEnabled_
        -bool updatesDeferred_
        +disableUpdates(bool deferred)
        +enableUpdates()
    }

    class Singleton~T~ {
        +static instance() T&
    }

    class Handle~T~ {
        -shared_ptr~Link~ link_
        +operator->()
        +currentLink()
        +empty()
    }

    class RelinkableHandle~T~ {
        +linkTo(shared_ptr)
    }

    Observable <|-- LazyObject : virtual
    Observer <|-- LazyObject : virtual
    Singleton <|-- ObservableSettings
    Handle <|-- RelinkableHandle
    Singleton <|-- Settings
    Singleton <|-- IndexManager

stateDiagram-v2
    [*] --> Dirty : 构造
    Dirty --> Calculating : calculate()
    Calculating --> Clean : performCalculations() 成功
    Calculating --> Failed : performCalculations() 抛异常
    Clean --> Dirty : update() 依赖变化
    Failed --> Dirty : update() 依赖变化
    Dirty --> Frozen : freeze()
    Clean --> Frozen : freeze()
    Frozen --> Dirty : unfreeze() + 补发通知

classDiagram
    class Date {
        -int_fast32_t serialNumber_  (距1899-12-31天数)
        +weekday() Weekday
        +dayOfMonth() Integer
        +month() Month
        +year() Year
        +operator+(Period) Date
        +operator-(Date) BigNatural
        +todaysDate()$ Date
        +minDate()$ Date (1901-01-01)
        +maxDate()$ Date (2199-12-31)
        +endOfMonth(Date)$ Date
        +nthWeekday(n,w,m,y)$ Date
    }

    class Period {
        -Integer length_
        -TimeUnit units_
        +length() Integer
        +units() TimeUnit
        +frequency() Frequency
        +normalize() Period (24Months to 2Years)
    }

    class Calendar {
        -shared_ptr~Impl~ impl_
        +isBusinessDay(Date) bool
        +isHoliday(Date) bool
        +adjust(Date, BDC) Date
        +advance(Date,n,unit,BDC) Date
        +businessDaysBetween(d1,d2) Integer
        +addHoliday(Date) / +removeHoliday(Date)
    }

    class DayCounter {
        -shared_ptr~Impl~ impl_
        +yearFraction(d1,d2,refStart,refEnd) Time
        +dayCount(d1,d2) Integer
    }

    class Schedule {
        -vector~Date~ dates_
        -vector~bool~ isRegular_
        +size() Size
        +at(i) Date
        +isRegular(i) bool
        +startDate() / endDate() Date
    }

    Date --> Period : arithmetic
    Calendar --> Date : adjusts
    DayCounter --> Date : computes
    Calendar *-- CalendarImpl : Bridge, 49+ 日历实现
    DayCounter *-- DayCounterImpl : Bridge, 13+ 计数约定

classDiagram
    class Interpolation {
        +operator()(x) Real
        +primitive(x) Real
        +derivative(x) Real
        +secondDerivative(x) Real
        +xMin() / xMax() Real
    }

    class OptimizationMethod {
        <<abstract>>
        +minimize(problem, criteria)* EndCriteria::Type
    }

    class Solver1D {
        +solve(f, accuracy, guess, xMin, xMax) Real
    }

    class Statistics {
        +add(value, weight)
        +mean() / variance() / skewness() / kurtosis()
        +errorEstimate() (= stdDev/sqrt(N))
    }

    OptimizationMethod <|-- LevenbergMarquardt : 阻尼最小二乘
    OptimizationMethod <|-- Simplex : Nelder-Mead 无需梯度
    OptimizationMethod <|-- ConjugateGradient
    Solver1D <|-- Brent : 自举中最常用
    Solver1D <|-- FiniteDifferenceNewtonSafe : 牛顿+边界保护

classDiagram
    class Currency {
        -shared_ptr~Data~ data_
        +name() / code() / numericCode()
        +triangulationCurrency() Currency
        +empty() bool
        +rounding() Rounding
    }

    class CurrencyData {
        +string name, code, symbol
        +Integer numeric, fractionsPerUnit
        +Rounding rounding
        +Currency triangulated
    }

    class ExchangeRate {
        +Type Direct / Derived
        +Currency source() / target()
        +Decimal rate()
        +Money exchange(Money) (双向)
        +chain(r1,r2)$ ExchangeRate (二叉树组合)
    }

    class ExchangeRateManager {
        +add(rate, startDate, endDate)
        +lookup(src,tgt,date) ExchangeRate
        +clear()
        -addKnownRates() (欧元遗留, TRY/TRL, RON/ROL)
    }

    Currency *-- CurrencyData : Flyweight, 所有同币种实例共享不可变Data
    ExchangeRate --> Currency : source/target
    ExchangeRateManager --> ExchangeRate : data_ entries

classDiagram
    class Quote {
        <<abstract>>
        +value()* Real
        +isValid()* bool
    }

    class SimpleQuote {
        -Real value_
        +setValue(Real) (赋值 to notifyObservers)
        +reset() (value_=Null)
    }

    class DerivedQuote~F~ {
        -Handle~Quote~ element_
        -F f_ (函数对象)
        +value() = f(element_->value()) (缓存)
        +update() cache=Null + notify
    }

    class CompositeQuote~F~ {
        -Handle~Quote~ e1_, e2_
        -F f_ (二元函数对象)
        +value() = f(e1_->value(), e2_->value())
    }

    class ImpliedStdDevQuote {
        -Handle~Quote~ forward_, price_
        -Real strike_, guess_
        +value() blackFormulaImpliedStdDev (反解BS)
    }

    class ForwardSwapQuote {
        -SwapIndex swapIndex_
        -Handle~Quote~ spread_
        +value() createSwap + fairRate
    }

    Quote <|-- SimpleQuote
    Quote <|-- DerivedQuote
    Quote <|-- CompositeQuote
    Quote <|-- ImpliedStdDevQuote : LazyObject
    Quote <|-- ForwardSwapQuote : LazyObject
    Quote <|-- ForwardValueQuote : Observer
    Quote <|-- LastFixingQuote : Observer

classDiagram
    class TermStructure {
        +referenceDate() / maxDate()
        +dayCounter() / calendar()
        +update()
    }

    class YieldTermStructure {
        +discount(Date) DiscountFactor
        +zeroRate(Date) InterestRate
        #discountImpl(Time)* DiscountFactor
    }

    class ZeroYieldStructure {
        #zeroYieldImpl(Time)* Rate
        #discountImpl(Time) = exp(-zeroYield*T)
    }

    class InterpolatedZeroCurve {
        -vector times_ / data_
        -Interpolation interpolation_
        #zeroYieldImpl(Time) = interpolation_(t)
    }

    class PiecewiseYieldCurve~Traits,Interp,Bootstrap~ {
        -vector helpers_
        +performCalculations() bootstrap.run()
    }

    TermStructure <|-- YieldTermStructure
    YieldTermStructure <|-- ZeroYieldStructure
    ZeroYieldStructure <|-- InterpolatedZeroCurve
    InterpolatedZeroCurve <|-- PiecewiseYieldCurve

classDiagram
    class BootstrapHelper~TS~ {
        -Handle~Quote~ quote_
        +quoteError()* Real (modelValue - marketValue)
        +setTermStructure(TS*) (自举迭代过程中动态设置)
    }

    BootstrapHelper <|-- RateHelper : TS=YieldTermStructure
    BootstrapHelper <|-- DefaultProbabilityHelper : TS=DefaultProbabilityTS
    RateHelper <|-- DepositRateHelper : 1+rate*yf = 1/disc
    RateHelper <|-- FraRateHelper : 远期利率一致性
    RateHelper <|-- SwapRateHelper : swap fairRate = quote
    RateHelper <|-- BondHelper : bond cleanPrice = quote
    DefaultProbabilityHelper <|-- SpreadCdsHelper : cds fairSpread = quote

classDiagram
    class VolatilityTermStructure {
        +minStrike() / maxStrike()
        +volatilityType()
    }

    class BlackVolTermStructure {
        +blackVol(Date, Strike) Volatility
        #blackVolImpl(Time, Strike)* Volatility
    }

    class BlackVarianceCurve {
        -mutable Interpolation varianceCurve_
        #blackVolImpl(t, strike) = sqrt(interp(t))
    }

    class BlackVarianceSurface {
        -mutable Interpolation2D varianceSurface_
        #blackVolImpl(t, strike) = sqrt(interp(t, k))
    }

    class SmileSection {
        
        +volatility(strike)* Volatility
        +atmLevel() Real
        +exerciseDate() / dayCounter()
    }

    VolatilityTermStructure <|-- BlackVolTermStructure
    BlackVolTermStructure <|-- BlackVarianceCurve : 1D 时间维度
    BlackVolTermStructure <|-- BlackVarianceSurface : 2D 时间x行权价
    SmileSection <|-- SabrSmileSection
    SmileSection <|-- InterpolatedSmileSection
    SmileSection <|-- FlatSmileSection

classDiagram
    class Index {
        <<abstract, Observable+Observer>>
        +name()* string
        +fixingCalendar()* Calendar
        +fixing(Date,bool)* Real
        +addFixing(Date,Real)
        +pastFixing(Date) Real
        +update() = notifyObservers()
    }

    class InterestRateIndex {
        <<abstract>>
        +familyName() / tenor() / fixingDays() / currency()
        +forecastFixing(Date)* Rate
        +maturityDate(Date)* Date
        +fixing(Date,bool) Real (★ Template Method)
    }

    class IborIndex {
        -Handle~YieldTermStructure~ termStructure_
        +forecastFixing(Date) = (disc/disc-1)/t
        +clone(Handle)* shared_ptr (★ Clone模式)
    }

    class SwapIndex {
        -shared_ptr~IborIndex~ iborIndex_
        -Handle~YieldTermStructure~ discount_
        +forecastFixing(Date) createSwap to setEngine to fairRate()
        +underlyingSwap(Date) shared_ptr
    }

    class IndexManager {
        -map name to TimeSeries~Real~ data_
        -map name to shared_ptr~Observable~ notifiers_
        +getHistory(name) / setHistory(name, ts)
        +addFixings(dates, values)
        +notifier(name) shared_ptr (延迟创建)
    }

    Index <|-- InterestRateIndex
    Index <|-- InflationIndex
    InterestRateIndex <|-- IborIndex
    InterestRateIndex <|-- SwapIndex
    IborIndex <|-- OvernightIndex
    Index --> IndexManager : 定息存储代理

sequenceDiagram
    participant Caller
    participant Idx as InterestRateIndex
    participant IM as IndexManager
    participant TS as TermStructure

    Caller->>Idx: fixing(fixDate, forecastTodaysFix)

    alt fixDate < today
        Idx->>IM: pastFixing(fixDate) = 历史值
    else fixDate == today
        Idx->>IM: pastFixing(fixDate)
        alt 历史值存在
            IM-->>Idx: 历史值
        else forecastTodaysFix==true
            Idx->>TS: discount(valDate), discount(matDate)
            Idx->>Idx: forecastFixing() = 远期预测
        end
    else fixDate > today
        Idx->>TS: discount(valDate), discount(matDate)
        Idx->>Idx: forecastFixing() = 远期预测
    end

    Idx-->>Caller: fixing 结果

classDiagram
    class StochasticProcess {
        <<abstract N-D, Observer+Observable>>
        +size()* Size
        +factors() Size
        +initialValues()* Array
        +drift(t,x)* Array
        +diffusion(t,x)* Matrix
        +evolve(t0,x0,dt,dw) Array
        +expectation(t0,x0,dt) Array
    }

    class StochasticProcess1D {
        <<abstract 1-D>>
        +x0()* Real
        +drift(t,x)* Real
        +diffusion(t,x)* Real
        +evolve(t0,x0,dt,dw) Real
        ★ 私有: N-D to 1-D 包装 (size=1 etc.)
    }

    class GeneralizedBlackScholesProcess {
        -Handle x0_, dividendTS_, riskFreeTS_, blackVolTS_
        +drift = (r-q)*S, diffusion = vol*S
        ★ 条件解析矩 (vol不依赖strike时)
        +forceDiscretization_ (强制使用离散化)
    }

    class HestonProcess {
        -Handle s0_, v0_
        -kappa, theta, sigma, rho
        Size=2, factors=2 (或3, 独立方差)
        ★ 8种离散化方案
    }

    class OrnsteinUhlenbeckProcess {
        -x0, speed, level, sigma
        ★ 解析矩 (绕过离散化)
    }

    class HullWhiteProcess {
        -shared_ptr~OUProcess~ ouProcess_
        ★ 组合模式而非继承: r(t)=OU(t)+alpha(t)
    }

    class G2Process {
        -shared_ptr~OUProcess~ xProcess_, yProcess_
        -Real rho_ (两因子相关)
    }

    StochasticProcess <|-- StochasticProcess1D
    StochasticProcess <|-- HestonProcess
    StochasticProcess <|-- G2Process
    StochasticProcess1D <|-- GeneralizedBlackScholesProcess
    StochasticProcess1D <|-- OrnsteinUhlenbeckProcess
    StochasticProcess1D <|-- CoxIngersollRossProcess
    HestonProcess <|-- BatesProcess : 加跳跃
    StochasticProcess1D <|-- HullWhiteProcess : 组合

classDiagram
    class CalibratedModel {
        -vector~Parameter~ arguments_
        +calibrate(helpers, method, criteria)
        +params() / setParams(Array)
        +constraint() Constraint
        +update() generateArguments+notifyObservers
        #generateArguments()*
    }

    class OneFactorAffineModel {
        <<abstract>>
        +A(t,T)* / B(t,T)*
        discountBond = exp(A - B*x)
    }

    class Vasicek {
        -r0, a, b, sigma, lambda
        +解析 A(t,T), B(t,T)
        +内嵌 Dynamics = OUProcess
    }

    class HullWhite {
        -Parameter phi_ (时变均值回复)
        +generateArguments() fit国债曲线
    }

    class HestonModel {
        -HestonProcess process_
        +FellerConstraint (2*kappa*theta >= sigma²)
    }

    class MarketModel {
        <<interface>>
        +pseudoRoot(i)* Matrix
        +numberOfSteps()* Size
        +numberOfRates()* Size
    }

    class MarketModelEvolver {
        +startNewPath()*
        +advanceStep()*
        +currentState()* CurveState
    }

    class MarketModelMultiProduct {
        <<interface>>
        +possibleCashFlows()*
        +exerciseTimes()*
    }

    CalibratedModel <|-- OneFactorAffineModel
    OneFactorAffineModel <|-- Vasicek
    Vasicek <|-- HullWhite
    OneFactorAffineModel <|-- CIR
    CalibratedModel <|-- HestonModel
    CalibratedModel <|-- G2
    CalibratedModel <|-- Gaussian1dModel
    Gaussian1dModel <|-- Gsr : 分段 sigma + reversion

sequenceDiagram
    participant CM as CalibratedModel
    participant LM as LevenbergMarquardt
    participant H as CalibrationHelper

    CM->>LM: minimize(costFunc, endCriteria)

    loop 每次 LM 迭代
        LM->>CM: setParams(x_new)
        CM->>CM: generateArguments() 重建状态
        CM->>CM: notifyObservers() 通知Helpers

        loop 每个 helper
            LM->>H: calibrationError()
            H->>H: modelValue() - marketValue()
        end

        LM->>LM: 数值差分计算 Jacobian
        LM->>LM: 解 (J^T J + λI) dx = -J^T f
        LM->>LM: x_{k+1} = x_k + dx
    end

    CM-->>CM: 校准完成

classDiagram
    class Fdm1dMesher {
        +location(i) Real
        +dplus(i) / dminus(i) Real
    }

    class FdmLinearOpComposite {
        <<abstract>>
        +size()* Size (维度数)
        +apply_direction(d,r)* Array
        +solve_splitting(d,r,s)* Array
        +apply_mixed(r)* Array (混合导数项)
    }

    class FdmHestonOp {
        -EquityPart + VariancePart + MixedDerivative
    }

    class FdmBatesOp {
        -FdmHestonOp hestonOp_
        +apply_mixed() 添加 Gauss-Hermite 跳跃积分
    }

    class FdmBackwardSolver {
        +rollback(from, to, steps) (ADI 回滚)
    }

    class Fdm1DimSolver {
        -LazyObject
        +interpolateAt(x) Real
        +thetaAt(x) Real
    }

    Fdm1dMesher <|-- Uniform1dMesher
    Fdm1dMesher <|-- FdmBlackScholesMesher
    Fdm1dMesher <|-- FdmHestonVarianceMesher : 集中网格
    FdmLinearOpComposite <|-- FdmHestonOp
    FdmLinearOpComposite <|-- FdmBatesOp : 装饰器
    FdmBatesOp --> FdmHestonOp : composition

classDiagram
    class CashFlow {
        <<abstract, Event+LazyObject>>
        +date()* Date
        +amount()* Real
    }

    class Coupon {
        <<abstract>>
        +nominal()* Real
        +rate()* Rate
        +accrualStartDate()* / accrualEndDate()*
        +accruedAmount(Date)* Real
    }

    class FloatingRateCoupon {
        <<abstract>>
        -shared_ptr~InterestRateIndex~ index_
        -shared_ptr~FloatingRateCouponPricer~ pricer_
        -Real gearing_ / Spread spread_
        +setPricer(p) (可插拔定价器)
        +indexFixing() / adjustedFixing()
        #performCalculations() pricer_->swapletRate()
    }

    class CappedFlooredCoupon {
        -shared_ptr~FloatingRateCoupon~ underlying_
        -Rate cap_ / floor_
        +rate() = min(max(underlying->rate(), floor), cap)
    }

    class FloatingRateCouponPricer {
        <<abstract>>
        +swapletPrice()* / swapletRate()*
        +capletPrice(cap)* / capletRate(cap)*
        +floorletPrice(floor)* / floorletRate(floor)*
        +initialize(FloatingRateCoupon)*
    }

    CashFlow <|-- Coupon
    CashFlow <|-- SimpleCashFlow
    Coupon <|-- FixedRateCoupon
    Coupon <|-- FloatingRateCoupon
    FloatingRateCoupon <|-- IborCoupon
    FloatingRateCoupon <|-- CmsCoupon
    FloatingRateCoupon <|-- OvernightIndexedCoupon
    FloatingRateCoupon <|-- CappedFlooredCoupon : 装饰器
    FloatingRateCoupon <|-- DigitalCoupon : 装饰器
    FloatingRateCoupon --> FloatingRateCouponPricer : 策略模式

classDiagram
    class Instrument {
        
        -shared_ptr~PricingEngine~ engine_
        +NPV() / errorEstimate() / valuationDate()
        +setPricingEngine(engine) (策略模式)
        #setupArguments(args)*
        #fetchResults(results)*
        #performCalculations() reset to validate to calculate to fetch
    }

    class Option {
        +payoff() Payoff
        +exercise() Exercise
    }

    class OneAssetOption {
        +delta() / gamma() / theta() / vega() / rho()
    }

    class Swap {
        +legNPV(j) / legBPS(j)
        +deepUpdate() (优化通知图)
    }

    class Bond {
        +cleanPrice() / dirtyPrice() / yield()
        +accruedAmount() Real
    }

    class CreditDefaultSwap {
        +fairSpread() / fairUpfront()
        +impliedHazardRate() Real
    }

    Instrument <|-- Option
    Instrument <|-- Swap
    Instrument <|-- Bond
    Instrument <|-- CreditDefaultSwap
    Instrument <|-- Forward
    Instrument <|-- Stock
    Option <|-- OneAssetOption
    OneAssetOption <|-- VanillaOption
    OneAssetOption <|-- BarrierOption
    Option <|-- Swaption

sequenceDiagram
    participant User
    participant Inst as Instrument
    participant LO as LazyObject
    participant Eng as PricingEngine
    participant MD as MarketData

    User->>Inst: NPV()
    Inst->>LO: calculate()

    alt isExpired()
        Inst->>Inst: setupExpired() NPV=0
    else not expired
        Inst->>Inst: performCalculations()
        Inst->>Eng: reset()
        Inst->>Eng: setupArguments(args) (填充 strike, dates...)
        Eng->>Eng: arguments.validate()
        Eng->>Eng: calculate()
        Note over Eng: 1. query Handles for market data
        Note over Eng: 2. run numerical method
        Note over Eng: 3. write results_.value, delta, gamma...
        Inst->>Eng: fetchResults(results) (读回计算结果)
    end
    Inst-->>User: NPV_

    Note over MD,Inst: 市场数据变化后:
    MD->>Eng: update() via Observer chain
    Eng->>Inst: notifyObservers()
    Inst->>LO: calculated_ = false

classDiagram
    class PricingEngine {
        <<abstract, Observable>>
        +getArguments()* / getResults()*
        +reset()* / calculate()*
    }
    note for PricingEngine "嵌套类: arguments { validate() } / results { reset() }"

    class GenericEngine~Args,Results~ {
        -mutable Args arguments_
        -mutable Results results_
        ★ calculate() writes to mutable results_
    }

    class GenericModelEngine~Model,Args,Results~ {
        -Handle~Model~ model_
        +registerWith(model_) (Observer)
    }

    class McSimulation~MC,RNG,S~ {
        +calculate(accuracy, maxSamples)
        +pathPricer()* / pathGenerator()* / timeGrid()*
    }

    class BlackStyleSwaptionEngine~Spec~ {
        ★ Policy-Based: Black76Spec / BachelierSpec
    }

    PricingEngine <|-- GenericEngine
    GenericEngine <|-- GenericModelEngine
    GenericEngine <|-- AnalyticEuropeanEngine
    GenericEngine <|-- FdBlackScholesVanillaEngine
    GenericEngine <|-- BlackSwaptionEngine
    MCEuropeanEngine --|> GenericEngine
    MCEuropeanEngine --|> McSimulation : Mixin

graph TD
    subgraph CORE["核心基础设施"]
        types["types.hpp"]
        errors["errors.hpp"]
        qldefines["qldefines.hpp"]
        userconfig["userconfig.hpp"]
        sp_inc["shared_ptr.hpp"]
    end

    subgraph PATTERNS["模式层"]
        singleton["singleton.hpp"]
        observable["observable.hpp"]
        lazyobject["lazyobject.hpp"]
        handle["handle.hpp"]
    end

    subgraph UTILITY["基础工具层"]
        time["time/"]
        utilities["utilities/"]
        math["math/"]
        currencies["currencies/"]
    end

    subgraph DATA["市场数据层"]
        quotes["quotes/"]
        termstructures["termstructures/"]
        indexes["indexes/"]
    end

    subgraph MODELING["模型层"]
        processes["processes/"]
        models["models/"]
    end

    subgraph METHODS["方法层"]
        finitediff["finitedifferences/"]
        lattices["lattices/"]
        montecarlo["montecarlo/"]
    end

    subgraph APP["应用层"]
        cashflows["cashflows/"]
        instruments["instruments/"]
        pricingengines["pricingengines/"]
    end

    subgraph EXTRAS["实验与遗留"]
        experimental["experimental/"]
        legacy["legacy/"]
    end

    types --> observable
    types --> time
    types --> utilities
    types --> termstructures
    errors --> observable
    errors --> time
    errors --> utilities
    errors --> termstructures

    singleton --> observable
    observable --> lazyobject
    observable --> handle
    handle --> quotes
    handle --> termstructures
    handle --> indexes
    handle --> models
    handle --> processes

    time --> termstructures
    time --> cashflows
    time --> indexes
    time --> instruments

    utilities --> termstructures

    math --> termstructures
    math --> models
    math --> finitediff
    math --> montecarlo
    math --> lattices

    currencies --> indexes
    currencies --> cashflows
    currencies --> instruments

    quotes --> termstructures
    quotes --> indexes

    termstructures --> indexes
    termstructures --> processes
    termstructures --> models
    termstructures --> pricingengines

    processes --> models
    processes --> finitediff
    processes --> montecarlo
    processes --> lattices

    models --> pricingengines

    indexes --> cashflows
    indexes --> pricingengines
    indexes --> instruments

    finitediff --> pricingengines
    lattices --> pricingengines
    montecarlo --> pricingengines

    cashflows --> instruments
    instruments --> pricingengines
    pricingengines --> instruments

    instruments --> experimental
    pricingengines --> experimental
    processes --> experimental
    models --> experimental
    finitediff --> experimental

    models --> legacy