FICC 回测使用说明及案例

在 FICC (Fixed Income, Currencies, and Commodities,固定收益、外汇与大宗商品)市场中,跨资产类别的协同配置与风险对冲同样是主流范式。无论是利率债与利率衍生品的久期管理、外汇与大宗商品的宏观套利,还是信用风险缓释工具的组合运用,投资组合往往需要同时涵盖债券、外汇、商品及其对应的期货、掉期、期权等工具。相比单一资产或单类别的回测,多资产联合回测能够更真实地反映保证金占用、跨品种风险暴露以及资金成本,从而更贴近实盘表现。基于这一需求,DolphinDB 推出了面向 FICC 的多资产混合回测,使用户能够在同一框架下实现利率、汇率、商品等多品种协同回测,并通过单一账户或多账户灵活管理现金、持仓与担保品。本文将以三个典型案例来展示 DolphinDB 在 FICC 多资产回测中的应用方法与实际优势。

1. 案例介绍与方案概述

本文将展示三个 FICC 回测案例:

  • XBOND 现券日内交易策略:基于十年国开债 XBOND 现券行情,结合双均线信号进行日内交易,并施加日终平仓与止损、敞口等风控约束。

  • 做市双边策略及平盘策略:在做市场景下同时维护买卖双边报价,并在触发条件时执行平盘以控制库存与风险。

  • 债券与利率互换套利策略:利用债券与利率互换之间的定价关系构建套利组合,在统一账户下完成跨品种开平仓与资金管理。

1.1 XBOND 交易策略

中国银行间债券市场长期以场外询价交易为主导,效率低且透明度不足。为提升市场流动性,中国外汇交易中心于 2016 年 9 月推出 X-Bond 匿名点击业务,参与机构匿名报价后由系统基于双边授信自动匹配成交,未匹配报价展示于行情界面供对手方点击,有效降低了信息不对称和询价成本。X-Bond 分上午和下午两个连续交易时段,提供可拆量、多档行情功能,便利机构集中建仓。截至 2022 年末,X-Bond 在新发关键期限利率债的交易占比已达约 30%,现券程序化交易集中于 10 年期活跃品种,策略开发需特别注意其盘口深度较浅(平均约 3000 万元)的特点,须将资金容量和滑点控制作为重点考量。

本文案例将基于十年国开债的快照、分钟与成交行情,构建 XBOND 现券日内双均线交易策略,展示DolphinDB 的 FICC 回测框架在现券量化策略研发中的完整流程。

1.2 做市双边策略及平盘策略

做市商通过持续提供债券买卖双边报价为市场注入流动性并赚取价差收益。做市双边策略的核心在于持续报出买卖价并形成稳定价差,通过市场反馈校准报价,形成“定价赋能交易、交易校准报价”的闭环,实际操作中需在提供流动性与控制债券持仓规模之间寻求平衡——持仓过大则利率风险过高,持仓过小则报价价差扩大甚至出现“空仓报价”。平盘策略则是对做市过程中被动积累的单向头寸进行对冲或了结以控制风险敞口,核心任务包括监测净头寸、评估 DV01 (Dollar Value of 1 Basis Point,基点价值)风险并选择合适时机进行反向交易回归中性。回测模拟做市策略时需特别关注报价行情与成交行情的区别,策略需在各档报价上决策是否提供流动性,并考虑订单成交的不确定性。

在接下来的案例中,基于中国外汇交易中心(China Foreign Exchange Trade System,CFETS)做市双边、XBOND 及货币经纪等快照行情,构建做市双边报价与平盘策略,展示在有限盘口深度下动态管理做市库存与价差收益的回测流程。

1.3 债券和利率互换套利策略

利率互换(Interest Rate Swap,IRS)是重要的利率衍生品工具,截至 2023 年 11 月互换合约名义本金达 2.5 万亿元。债券与 IRS 套利利用两者定价偏离获取收益,其核心在于债券可视为固定现金流组合而 IRS 可实现固定与浮动利率的分离,通过同时构建债券和 IRS 头寸可合成不同风险收益特征的组合。常见套利模式包括“买入现券+Pay Fixed IRS” 锁定正利差,以及浮息债与 IRS 组合套利——买入浮息债并做空 IRS 以合成固息债头寸,该策略面临的主要风险是浮息债基准利率与 IRS 浮动端参考利率之间不完全匹配带来的基差风险。套利空间有限,交易成本控制是盈利关键,回测模拟该策略需同时处理现券和 IRS 两个品种的行情与头寸,且套利对成交价格精度高度敏感,对回测引擎的多资产支持能力和撮合准确性均提出较高要求。

在最后的案例中,基于 5 年期国债活跃券与 5 年期 IRS 的分钟级行情,构建现券–IRS 基差均值回归套利策略,展示多资产配对交易中捕捉定价偏离与精确控制对冲比率的完整方法。

1.4 DolphinDB FICC 回测解决方案概述

DolphinDB 回测插件现已支持 FICC 策略回测,包括 XBOND 债券品种、做市双边报价、利率互换策略回测。在 FICC 回测框架下,用户可以同时加载现货、债券、期货、利率互换等多资产的行情与交易规则,在引擎中实现资金、保证金与风险控制的统一管理,从而获得更贴近实盘的模拟效果。与传统的回测相比, FICC 回测在引擎配置、账户管理以及行情数据输入方式等方面均有所扩展,构成了一套更加完整的解决方案。

多资产统一数据建模能力方面,框架针对自营业务的债券、利率互换及交易所债券场景,通过四大核心模块实现需求精准匹配:

  • 多资产数据模型:支持债券、国债期货、利率互换、双边报价等多种资产类型的标准化数据模型定义,为量化分析提供统一的数据基础。

  • 定价函数:DolphinDB 提供丰富的定价函数库,支持债券、利率互换、国债期货等复杂金融产品的精确定价,满足各类估值需求。

  • 实时定价引擎:基于 DolphinDB 高性能计算引擎,实现对海量资产的实时估值和风险指标(如久期、DV01)计算,确保定价的及时性,支持回测和仿真一体化。

  • 曲线构建和组合管理:支持收益率曲线的动态构建和管理,并提供强大的投资组合管理功能,包括风险度量、绩效归因和组合优化。

深度贴合固收业务的原生 FICC 量化策略回测框架:摒弃通用框架的“拿来主义”,内置 FICC 业务专属指标引擎,自动完成 ytm、cleanPrice 和 dirtyPrice 三者互算,并实时核算应计利息、久期、DV01 等核心因子,无需额外开发适配。原生支持基于收益率(Yield to Maturity,YTM)的下单与撮合逻辑、全价结算模式,完美复刻交易员在做市、套利中的真实报价习惯。

与其它品种回测的主要差异:

  • 引擎相关配置:

    • 账户配置:初始资金 cash 为 DOUBLE 类型,统一配置资产账户管理。

    • 策略类型:FICC 回测须将 strategyGroup 设为 "FICC"。

    • 行情配置: msg 是字典,其 key 可为 snapshot、ohlc、transaction、curveSignal 四种,值为对应的行情数据。

    • 合约配置:配置项 securityReference 为字典类型,代表合约的基本信息表,key 支持 spot、futures、xbond、xswap、swapCurve、swapAssetPriceHistCurve,value 是一个表,代表对应的基础信息表,具体字段参考配置文件。

    • 回调机制配置:设置 universe 标的池,是一个 ANY 类型向量,其元素是 STRING 类型向量;开启 enableBondLending 允许债券卖空操作。同时间戳的行情按 onTransaction、onCurveSignal、onBar、onSnapshot 顺序触发回调。

  • 行情数据输入:

    • 通过 appendQuotationMsg 接口插入数据;同一种行情类型下,不同资产可放同一张表,引擎按 securityReference 识别品种。

  • 交易层面:

    • 支持提交双边报价订单接口 submitQuoteOrder、取消双边报价订单接口 cancelQuotes,以及做市成交明细查询 getQuoteTradeDetails,以覆盖现券、IRS、做市等差异化场景。

2. 基于 DolphinDB 的 XBOND 交易策略

本案例演示如何在 DolphinDB 的 FICC 回测框架中,接入十年国开债的快照、分钟与成交行情,完成策略回调编写、引擎创建、行情注入与结果查看。策略示例为 XBOND 现券日内双均线:在 1 分钟线上识别金叉/死叉,并按对手价开平仓,同时满足日终平仓、单日/累计止损与净敞口上限等约束。

  • 指标计算: 1 分钟收盘价计算 MA10/MA30,带过滤阈值的金叉、死叉。

  • 交易信号: 金叉平空开多,死叉平多开空;日终清仓;触及止损则强平。

  • 止损逻辑: 净敞口 ≤ 5 亿,单日止损 -10 万,累计止损 -100 万。

2.1. 编写自定义策略

DolphinDB 回测采用事件驱动:行情到达、成交回报、日终结算等都会触发对应回调。本例中,信号在 onBar 中计算,交易与止损在 onSnapshot 中执行,日终平仓在 afterTrading 中完成。完整回调列表见接口文档。

本文所有代码均在 DolphinDB v3.00.6 环境下验证通过。

首先给出均线金叉/死叉的计算函数,样本不足时不发信号,交叉需结合上一期快慢线与过滤阈值:

def calcMaSignal(fast, slow, lastPx, entryFilter, prevFast, prevSlow){
    out = dict(STRING, ANY)
    out["golden"] = false
    out["death"] = false
    out["prevFast"] = prevFast
    out["prevSlow"] = prevSlow
    if (isNull(fast) or isNull(slow)) return out
    if (!isNull(prevFast) and !isNull(prevSlow)){
        if (prevFast <= prevSlow and fast > slow and lastPx >= slow + entryFilter) out["golden"] = true
        if (prevFast >= prevSlow and fast < slow and lastPx <= slow - entryFilter) out["death"] = true
    }
    out["prevFast"] = fast
    out["prevSlow"] = slow
    return out
}

在策略初始化函数 initialize 中,完成交易参数与运行状态的配置:设定交易标的、单笔委托数量、日内最大净敞口,以及单日止损限额与累计止损限额;同时配置均线开仓过滤阈值及止盈止损阈值。使用 context["closes"] 创建长度为 0 的 DOUBLE 类型数组,用于后续存储分钟收盘价序列。此外,将快慢均线前值、交易信号、当日盈亏、累计盈亏等状态变量置为初始值。

def initialize(mutable context){
    context["Lot"] = 1000000l
    context["MaxPos"] = 500000000l
    context["dayStop"] = -100000.0
    context["cumStop"] = -1000000.0
    context["filter"] = 0.01
    context["lastPx"] = NULL
    context["closes"] = array(DOUBLE, 0)
    context["prevFast"] = NULL
    context["prevSlow"] = NULL
    context["sig"] = 0
    context["dayPnl"] = 0.0
    context["cumPnl"] = 0.0
    context["entryPx"] = NULL
    context["tp"] = 0.1
}

在回调函数 beforeTrading 中,每日行情到来前重置当日运行状态:将当日盈亏清零,并清空交易信号与上一交易日缓存的买一、卖一,避免跨日沿用旧状态:

def beforeTrading(mutable context){
    context["dayPnl"] = 0.0
    context["sig"] = 0
    context["entryPx"] = NULL
}

在快照行情回调函数 onSnapshot 中,系统更新盘口缓存,并在交易时段内响应分钟线产生的均线信号:金叉时先平空,再按卖一开多;死叉时先平多,再按买一开空;开仓前校验净敞口不超过上限。与此同时,根据持仓与最新价估算浮动盈亏,监测是否触及单日或累计止损限额;一旦触发停机,则按对手价对剩余仓位强平并停止新开仓。在日终设置收盘信号,把持有的仓位都平掉。onSnapshot 函数的 data 参数为回测引擎传入的最新 snapshot 行情,对应 universe 标的池,若设置多个标的池,则应在行情回调函数onSnapshot、onBar 以及 onTransaction 中设置多个 data 参数分别与每个标的池对应;以下代码展示了此套策略的交易逻辑:

def onSnapshot(mutable context, data){
    bid1 = data.bidPrice[0]
    ask1 = data.askPrice[0]
    sym = data.symbol
    lot = context["Lot"]
    t = second(data.datetime)
    lastPx = context["lastPx"]

    pos = Backtest::getPosition(context["engine"], sym)
    longQ = long(pos.longPosition)
    shortQ = long(pos.shortPosition)
    net = longQ - shortQ
    
    context["cumPnl"] = pos.totalProfit
    if (isNull(context["cumPnl"])) context["cumPnl"] = 0.0
    pf = Backtest::getTotalPortfolios(context["engine"])
    context["dayPnl"] = pf.pnl - pf.floatingPnl
    if (isNull(context["dayPnl"])) context["dayPnl"] = 0.0

    // 强平:止损停机
    if (context["dayPnl"] <= context["dayStop"] or context["cumPnl"] <= context["cumStop"]){
        if (longQ > 0){
            Backtest::submitOrder(context["engine"], dict(`symbol`source`qty`orderType`direction`openClose`price, (sym, "XBOND", longQ, 5, 2, 2, bid1)), "强平")
            context["entryPx"] = NULL
        }
        if (shortQ > 0){
            Backtest::submitOrder(context["engine"], dict(`symbol`source`qty`orderType`direction`openClose`price, (sym, "XBOND", shortQ, 5, 1, 2, ask1)), "强平")
            context["entryPx"] = NULL
        }
        return
    }
    // 止盈
    if (longQ > 0 and !isNull(context["entryPx"]) and bid1 >= context["entryPx"] + context["tp"]){
        Backtest::submitOrder(context["engine"], dict(`symbol`source`qty`orderType`direction`openClose`price, (sym, "XBOND", longQ, 5, 2, 2, bid1)), "止盈")
        context["entryPx"] = NULL
        return
    }
    if (shortQ > 0 and !isNull(context["entryPx"]) and ask1 <= context["entryPx"] - context["tp"]){
        Backtest::submitOrder(context["engine"], dict(`symbol`source`qty`orderType`direction`openClose`price, (sym, "XBOND", shortQ, 5, 1, 2, ask1)), "止盈")
        context["entryPx"] = NULL
        return
    }

    // 均线信号:先平反向,再开 Lot
    sig = context["sig"]
    context["sig"] = 0

    if (sig == 1){
        if (shortQ > 0){
            Backtest::submitOrder(context["engine"], dict(`symbol`source`qty`orderType`direction`openClose`price, (sym, "XBOND", shortQ, 5, 1, 2, ask1)), "平空")
            context["entryPx"] = NULL
            net = longQ
        }
        if (net + lot <= context["MaxPos"]){
            Backtest::submitOrder(context["engine"], dict(`symbol`source`qty`orderType`direction`openClose`price, (sym, "XBOND", lot, 5, 1, 1, ask1)), "开多")
            context["entryPx"] = ask1
        }
    }
    if (sig == -1){
        if (longQ > 0){
            Backtest::submitOrder(context["engine"], dict(`symbol`source`qty`orderType`direction`openClose`price, (sym, "XBOND", longQ, 5, 2, 2, bid1)), "平多")
            context["entryPx"] = NULL
            net = -shortQ
        }
        if (net - lot >= -context["MaxPos"]){
            Backtest::submitOrder(context["engine"], dict(`symbol`source`qty`orderType`direction`openClose`price, (sym, "XBOND", lot, 5, 2, 1, bid1)), "开空")
            context["entryPx"] = bid1
        }
    }
    // 尾盘平仓
    if (t >= 16:15:00){
        if (longQ > 0){
            Backtest::submitOrder(context["engine"],
                dict(`symbol`source`qty`orderType`direction`openClose`price,
                (sym, "XBOND", longQ, 5, 2, 2, bid1)), "收盘")
            context["entryPx"] = NULL
        }
        if (shortQ > 0 ){
            Backtest::submitOrder(context["engine"],
                dict(`symbol`source`qty`orderType`direction`openClose`price,
                (sym, "XBOND", shortQ, 5, 1, 2, ask1)), "收盘")
            context["entryPx"] = NULL
        }
        return
    }
}

getPosition 函数接口可以获取当前时刻的多头和空头头寸;这里的 Backtest::submitOrder 是回测引擎提供的下单接口:

Backtest::submitOrder(engine, msg, [label=""])
//engine 引擎实例
//msg:订单信息元组或表,(标的代码, 行情来源,订单数量, 订单类型, 下单方向, 开仓平仓标志,委托价格)
//label:可选参数,方便用于对订单进行分类

在策略回调函数 onBar 中,传入的是标的的 OHLC 行情,更新最新价并识别金叉与死叉信号,存入 context 供 onSnapshot 做交易判断:

def onBar(mutable context, data){
    context["lastPx"] = data.close
    s = calcMaSignal(data.ma10, data.ma30, context["lastPx"], context["filter"], context["prevFast"], context["prevSlow"])
    context["prevFast"] = s["prevFast"]
    context["prevSlow"] = s["prevSlow"]
    if (s["golden"]) context["sig"] = 1
    if (s["death"]) context["sig"] = -1
}

在策略回调函数 onTransaction 中,系统接收回测引擎推送的最新成交行情,并将成交价写入 context["lastPx"],用于更新定价基准,供后续浮动盈亏估算与交易决策使用。

def onTransaction(mutable context, data){
    context["lastPx"] = data.price
}

2.2. 根据策略设置相应的配置参数

回测的起止日期、初始资金、滑点等均可通过参数配置。标的池 universe 为向量,本例长度为 1,存放需要交易的十年国债标的。这些参数允许用户灵活调整,以模拟不同的市场环境和交易策略效果;本案例使用快照+分钟+成交行情,dataType 应设置为 3;matchingMode = 3 表示见价成交模式;固收场景下 strategyGroup 须为 "FICC",允许债券平仓并输出交易日志:

universe = array(ANY, 1)
universe[0] = ["250210.T1"]
config = {
    startDate: begt,
    endDate: endt,
    strategyGroup: "FICC",
    cash: 1e10,
    dataType: 3,
    matchingMode: 3,
    universe: universe,
    enableBondLending: true,
    outputOrderInfo: true
}

2.3. 创建回测引擎

创建 FICC 回测时,还需配置债券合约参考信息表 bondRef(乘数、最小变动价位、票息、保证金、手续费等),并设置 securityReference:

securityReference = {"xbond": bondRef}

设置引擎名称、配置项与事件回调后,先通过 Backtest::dropBacktestEngine 接口清除同名引擎,通过 Backtest::createBacktester 创建回测引擎。第四个参数表示是否开启 JIT,默认 false,暂不支持 JIT。

callbacks = {
    initialize: initialize,
    beforeTrading: beforeTrading,
    onSnapshot: onSnapshot,
    onBar: onBar,
    onTransaction: onTransaction,
    afterTrading: afterTrading
}
strategyName = "XBOND_intraday"
try{ Backtest::dropBacktestEngine(strategyName) }catch(ex){}
go
engine = Backtest::createBacktester(strategyName, config, callbacks, false, security...

Backtest::createBacktester 用于创建回测引擎,参数说明如下:

Backtest::createBacktester(name, config, eventCallbacks, securityReference)
//name表示回测引擎名称
//config 字典类型,表示回测引擎的配置项
//eventCallbacks 字典类型,表示策略回调函数
//securityReference 字典类型,合约的基本信息表,key 是回测的资产类型,value 是一个表,代表相应的基本信息表。

2.4. 执行回测引擎

先设置行情字典,msg 是字典形式,key 可取 snapshot、ohlc、transaction、curveSignal 四种,值为对应的行情数据表

msg = dict(STRING, ANY)
msg["snapshot"] = snapshot
msg["ohlc"] = ohlc
msg["transaction"] = transaction

通过 appendQuotationMsg 接口向引擎插入行情并执行回测:

Backtest::appendQuotationMsg(engine, msg)

通过appendEndMarker 接口结束回测:

Backtest::appendEndMarker(engine)

2.5. 获取回测结果

回测结束后,可通过接口获取成交明细、收益汇总以及组合权益与资金等结果。使用 getTradeDetails 查看成交明细,getReturnSummary 查看收益统计,getTotalPortfolios 查看组合层面的权益与可用资金变化:

tradeDetails = select * from Backtest::getTradeDetails(engine)
tradeDetails = select * from Backtest::getTradeDetails(engine) where orderStatus in [0,1]
returnSummary = Backtest::getReturnSummary(engine)
TotalPortfolios = Backtest::getTotalPortfolios(engine)
print(TotalPortfolios)

下图为本例获得的交易明细数据:



图 1. 图 2-1 XBOND 策略交易明细

3. 基于 DolphinDB 的做市双边策略

债券双边报价做市的核心是在同一标的上持续提供买入与卖出意向,为市场提供流动性,并尝试从买卖价差中获得收益。与单方向交易不同,做市策略不仅要判断合理报价,还必须同时管理订单生命周期、成交后的方向性库存、资金占用、借券约束以及行情过期风险。

在银行间市场,做市商需要应对三类问题:

  1. 报价生成:如何基于市场最优价生成有竞争力的双边报价,同时避免报价过窄或过宽;

  2. 报价维护:当市场行情变动时,如何判断是否需要撤单重报,避免频繁改价或报价失效;

  3. 敞口管理:报价被点击后,如何快速挂出反向平盘单,控制日内敞口。

本策略围绕上述三个问题展开,构建一套双边报价 + 平盘管理的完整做市逻辑。具体策略目标如下:

  • 从非做市行情中维护每只债券的一档最优买入、卖出收益率。

  • 按固定 bp 偏移生成双边收益率,并将报价价差限制在允许区间。

  • 仅在市场变化达到改价阈值时撤单重报,减少无效订单更新。

  • 发生报价成交时,提交反向平盘报价。

3.1. 编写自定义策略

策略由两个辅助函数和三个回调函数组成。

  • clampSpread 将价差夹在最小容忍度 N 与最大容忍度 M之间。

  • beforeTrading 在盘前初始化状态。

  • onSnapshot 是快照行情回调,也是策略的主执行函数。

策略辅助函数:clampSpread

def clampSpread(myBidY, myAskY, N, M, scale){
	// 将收益率报价的正价差限制在 [N, M] bp 范围内。
	// myBidY/myAskY:未经约束的买入/卖出收益率;N/M:最小/最大价差(bp);
	// scale:bp 到行情收益率单位的换算系数。返回修正后的两侧报价和最终价差。
	// 收益率报价中,本策略以 bidYTM-askYTM 定义正向做市价差。
	sp = (myBidY - myAskY) / scale
	// 输入缺失时不修正价格,由调用方后续终止本次报价。
	if (isNull(sp)) return myBidY, myAskY, NULL
	// 非正价差无法构成当前策略定义下的有效双边报价,保持原值返回。
	if (sp <= 0) return myBidY, myAskY, sp
	if (sp < N){
		// 价差过窄:保持中点不变,对称扩大到 N bp。
		mid = (myBidY + myAskY) / 2.0
		half = N * scale / 2.0
		return mid + half, mid - half, N
	}
	if (sp > M){
		// 价差过宽:保持中点不变,对称收窄到 M bp,提升报价竞争力。
		mid = (myBidY + myAskY) / 2.0
		half = M * scale / 2.0
		return mid + half, mid - half, M
	}
	// 价差已位于允许区间,直接使用原始报价。
	return myBidY, myAskY, sp
}

盘前处理函数:beforeTrading

beforeTrading (mutable context) 在当日交易前执行,在这里我们初始化券的行情最优价、订单报价、是否在报状态等全局变量。

def  beforeTrading(mutable context){
	// 每日重置单券状态,避免跨日引用旧行情和旧报价。
	context.bestBidY = double(NULL)
	context.bestAskY = double(NULL)
	// 当前双边报价收益率与报价状态。
	context.myBidY = double(NULL)
	context.myAskY = double(NULL)
	context.quoting = false
	// 动态最小价差初始为 1bp;报价 ID 直接保存接口返回值。
	context.N = 1.0
	context.quoteIds = []
}

快照决策函数:onSnapshot

onSnapshot(mutable context, data) 是快照行情回调,也是策略的主执行函数。负责单券的行情更新、报价维护、触价后的持仓处理,以及收盘平仓。每收到一条快照执行一次,状态直接保存在 context.bestBidY 等变量中。具体策略的实现分为 6 个步骤实现,大致如下:

def onSnapshot(mutable context, data){
    // onSnapshot 是策略主回调,每到达一条债券快照即执行一次。
	// 快照包含 symbol/source 以及多档 bidYTM/askYTM;本策略只使用第一档收益率。
	sym = data.symbol
	// ---------- Step 1:收盘后撤单平仓,停止新报价 ----------
    // ---------- Step 2:按行情来源更新参考报价 ----------
    // ---------- Step 3:模拟判断已有报价是否可能发生成交 ----------
    // ---------- Step 4:校验市场最优并生成候选双边报价 ----------
    // ---------- Step 5:执行改价阈值检查 ----------
    // ---------- Step 6:撤销旧报价并提交新双边报价 ----------
}

Step 1:首先需要处理目标券和收盘前撤单平仓的操作。

  • 只处理目标券:读取 data.symbol,与 context.targetSymbol 比较。如果不是指定债券,直接返回。

  • 16:00 后撤单并平仓,当行情时间达到或超过 16点:

    • 撤销已有双边报价,清空报价订单号,设置报价状态 。

    • 撤销普通在途订单。

    • 查询净持仓:flatQty = 多头数量 − 空头数量。

      • 净多头:按当前快照的买一收益率提交卖出平仓单。

      • 净空头:按当前快照的卖一收益率提交买入平仓单。

随后直接返回,不再生成开仓报价。后续收盘快照继续执行上述操作,处理尚未平完的持仓。

// 标的池与行情表均过滤单券,此处再限制回调只能对目标券下单。
if (string(sym) != context.targetSymbol) return
// ---------- Step 1:收盘后撤单平仓,停止新报价 ----------
if(second(context.tradeTime)>=16:00:00){
		// 每一个交易日16开始,平头寸
		// 取消所有在途订单
		ids = context.quoteIds
		if (size(ids) > 0){
			// 避免原开仓报价在平盘期间继续发生交易。
			Backtest::cancelQuotes(context.engine, ids)
			context.quoteIds = []
		}
		context.quoting = false
		// FICC 不支持 cancelOrder 的 symbol 参数;本引擎仅处理目标券。
		Backtest::cancelOrder(context.engine)
		pos = Backtest::getPosition(context.engine, sym)
		flatQty = long(pos.longPosition)-long(pos.shortPosition)
		bidY = data.bidYTM[0]
		askY = data.askYTM[0]
		if ( flatQty > 0) {
              // 发生成交,债券多头:在卖出侧按成交收益率挂平仓量。
              Backtest::submitOrder(context.engine,
              dict(`symbol`source`qty`orderType`direction`openClose`ytm,
              (sym, "XBOND", flatQty, 5, 2, 2, bidY)), "平盘-卖出")
		}
		else if (abs(flatQty) >0){
			// 卖出侧发生成交,债券空头:在买入侧按成交收益率挂平仓量。
			// 取消所以在途订单
			Backtest::cancelOrder(context.engine)	
			Backtest::submitOrder(context.engine,
			     dict(`symbol`source`qty`orderType`direction`openClose`ytm,
			     (sym, "XBOND", abs(flatQty), 5, 1, 2, askY)), "平盘-买入")
		}
		return 
}

这里的 submitQuoteOrder 提交的是双边订单,cancelQuotes 取消双边订单:

Backtest::submitQuoteOrder(engine, msg, [label=""])
//engine 引擎实例
//msg:订单信息元组或表,(标的代码, 行情来源,买价,买订单数量, 卖价,卖订单数量, 开仓平仓标志)
//开仓时,bidQty和askQty都必须大于0,平仓时,其中一个大于0 即可
//label:可选参数,方便用于对订单进行分类

Step 2:根据行情来源更新最优收益率

// ---------- Step 2:按行情来源更新参考报价 ----------
src = data.source
// 排除做市商自身或同类做市渠道,避免用做市双边报价循环生成新报价。
if (src != "FIESP" and src != "ESP" and src != "CFETS_MM"){
    bidY = data.bidYTM[0]
    askY = data.askYTM[0]
    if (not isNull(bidY) and bidY > 0.){
        if (isNull(context.bestBidY) or bidY < context.bestBidY){
            context.bestBidY = bidY
        }
    }
    if (not isNull(askY) and askY > 0.){
        if (isNull(context.bestAskY) or askY > context.bestAskY){
            context.bestAskY = askY
        }
    }
}

Step 3:判断已有报价是否有可能发生成交,如果报价优于市场最优价,进行撤单操作。如果持仓数量超过限制,进行平仓操作。如果当前正在报价,检查 myBidY <= context.bestAskY 或者 myAskY >= context.bestBidY 任一条件成立,就撤销原双边报价。并查询实际净持仓是否超过阈值,超过进行平仓操作。

// force=true 表示报价成交,后续必须重新生成双边报价,不受改价阈值限制。
force = false
// ---------- Step 3:判断已有报价是否有可能发生成交 ----------
if (context.quoting){
    myBidY = context.myBidY
    myAskY = context.myAskY
    // 收益率与价格方向相反:
    // myBidY<=bestAskY 表示买价达到/穿过市场卖价;
    // myAskY>=bestBidY 表示卖价达到/穿过市场买价。
    // 相等或倒挂时,先撤销该券原双边报价,再按成交收益率提交反向平盘单。
    if (myBidY <= context.bestAskY or myAskY >= context.bestBidY){
        ids = context.quoteIds
        if (size(ids) > 0){
              // 避免原开仓报价在平盘期间继续发生交易。
              Backtest::cancelQuotes(context.engine, ids)
              context.quoteIds = []
          }
          context.quoting = false
          // 成交后扩大该券最小价差,降低连续被动成交和库存累积风险。
          context.N = 10.0
          force = true
      }
      // 从引擎读取真实持仓,用实际已形成的多/空数量确定平盘量。
      pos = Backtest::getPosition(context.engine, sym)
      flatQty = long(pos.longPosition)-long(pos.shortPosition)
      if ( flatQty > context.maxPos) {
          // 取消所以在途订单
          Backtest::cancelOrder(context.engine)
          // 发生成交,债券多头:在卖出侧按成交收益率挂平仓量。
           Backtest::submitOrder(context.engine,
           dict(`symbol`source`qty`orderType`direction`openClose`ytm,
           (sym, "XBOND", flatQty, 5, 2, 2, myBidY)), "平盘-卖出")
      }
      else if (flatQty < -context.maxPos){
          // 卖出侧发生成交,债券空头:在买入侧按成交收益率挂平仓量。
          // 取消所以在途订单
          Backtest::cancelOrder(context.engine)	
          Backtest::submitOrder(context.engine,
               dict(`symbol`source`qty`orderType`direction`openClose`ytm,
               (sym, "XBOND", abs(flatQty), 5, 1, 2, myAskY)), "平盘-买入")
      }
}

Step 4:计算并约束候选双边报价。这里通过 clampSpread 约束收益率价差。

// ---------- Step 4:校验市场最优并生成候选双边报价 ----------
// 未收到该券有效的非做市双边最优时,无法形成基准报价,直接返回。
if (isNull(context.bestBidY) or isNull(context.bestAskY)) return
// X/Y 为相对市场最优的收益率偏移(bp),scale 完成 bp 到行情单位的换算。
scale = context.scale
myBidY = context.bestBidY + context.X * scale
myAskY = context.bestAskY - context.Y * scale
// 将候选收益率价差限制在动态最小值 N 与最大值 M 之间。
myBidY, myAskY, sp = clampSpread(myBidY, myAskY, context.N, context.M, scale)
// 买入收益率必须严格高于卖出收益率,才能形成当前策略定义下的正报价区间。
if (isNull(sp) or myBidY <= myAskY) return

Step 5:执行改价阈值检查。

if (context.quoting and !force){
      // 将两侧新旧收益率变化转换成 bp。
      dBid = abs(myBidY - context.myBidY) / scale
      dAsk = abs(myAskY - context.myAskY) / scale
      // 两侧变化都小于阈值时保留原报价,减少无效撤单和重报。
      if (dBid < context.requoteThresh and dAsk < context.requoteThresh){
          return
      }
  }

Step 6:提交新双边报价并保存状态。

// ---------- Step 6:撤销旧报价并提交新双边报价 ----------
// 先更新上下文中的目标报价,供后续改价与成交判断使用。
context.myBidY = myBidY
context.myAskY = myAskY
// 已有未完成报价时先撤单,避免同一标的存在多组在途报价订单。
ids = context.quoteIds
if (size(ids) > 0){
    Backtest::cancelQuotes(context.engine, ids)
}
// openClose=1 表示开仓;双边委托量由 quoteQty 配置。
qid = Backtest::submitQuoteOrder(context.engine,
dict(`symbol`source`bidYTM`bidQty`askYTM`askQty`openClose,
    (sym, "XBOND", myBidY, context.quoteQty, myAskY, context.quoteQty, 1)), "提交双边报价")
// 保存报价 ID 并标记为正在报价。
context.quoteIds = qid
context.quoting = true

3.2. 根据策略设置相应的配置参数

回测的开始与结束日期、初始资金、标的资产都可以通过配置参数设置;strategyGroup 填 "FICC"。双边做市策略只支持标的为债券且是快照撮合模式(dataType = 0, 2, 3),本案例用的是快照行情撮合,dataType = 1 。并设置加点 X、减点 Y、价差上下限、单笔数量与改价阈值等参数。

universe = array(ANY, 1)
universe[0] = [targetSymbol]
config = {
	startDate: begt,
	endDate: endt,
	strategyGroup: "FICC",
	// 初始资金。
	cash: 1e12,
	dataType: 0,
	matchingMode: 1,
	universe: universe,
	// 允许形成债券空头,以支持卖出成交以及后续买入平盘。
	enableBondLending: true,
	// 在明细中保留订单状态和风控信息。
	outputOrderInfo: true,
	// 用户参数均放入 context,由 initialize/onSnapshot 共享:
	// X/Y 为报价偏移,M 为最大价差,scale=0.01 表示 1bp,
	// requoteThresh 为 1bp 改价阈值。
	context:{
		targetSymbol:targetSymbol,quoteQty:30000000l,
		X:1,Y:-3.,M:20.,scale:0.01,requoteThresh:1.,maxPos:1000000
	}
}

3.3. 创建回测引擎并执行回测

设置引擎名称、引擎配置项、策略回调以及债券基本信息等相应参数之后,通过接口 createBacktester 创建回测引擎实例。

callbacks = {
    initialize: initialize,
    onSnapshot: onSnapshot
}
strategyName = "MM_bilateral_flatten"
try{ Backtest::dropBacktestEngine(strategyName) }catch(ex){ print ex }
go
securityReference = {"xbond": bondRef}
// 每次使用独立引擎名称,不影响已有回测引擎。
strategyName = "MM_single_bond" 
try{ Backtest::dropBacktestEngine(strategyName) }catch(ex){ print ex }
// false 表示不启用 JIT;securityReference 为债券估值及持仓计算提供静态信息。
engine = Backtest::createBacktester(strategyName, config, callbacks, 
false, securityReference)
msg = dict(STRING, ANY)
msg["snapshot"] = snapshot
// 回放行情并在末尾追加结束标记
Backtest::appendQuotationMsg(engine, msg)
Backtest::appendEndMarker(engine)

3.4. 获取回测结果

FICC 的做市双边报价通过 getQuoteTradeDetails 函数接口获取交易明细,普通订单则通过 getTradeDetails 接口获取明细:

tradeDetails = select * from Backtest::getTradeDetails(engine)
dailyPosition = select * from  Backtest::getDailyPosition(engine)
// 双边报价专用明细:包含 PLACE/CANCEL、报价 ID、双边量价、成交状态和标签。
quoteDetails = select * from Backtest::getQuoteTradeDetails(engine)

其中 quoteDetails 用于核对做市双边报价与成交,totalPortfolios 用于追踪账户权益。



图 2. 图 3-1 做市双边策略交易明细

4. 债券与利率互换套利策略

本案例基于 5 年期国债活跃券 与 5 年期 IRS 的分钟级行情,构建现券–IRS 基差均值回归策略。核心思路:以国债 YTM 与 IRS 利率之差作为 Asset Swap 利差;当利差相对历史窗口均值突破 ±1.5σ 时开仓,回落至 ±0.3σ 内时平仓;开仓时按债券与互换修正久期做 DV01 中性配平:

指标计算:

  • 计算当前国债与 IRS 的利差,并在滚动窗口内估计均值与标准差,作为开平仓信号

  • 基于债券修正久期与互换近似修正久期进行 DV01 配平,确定互换手数

开仓逻辑:

  • 利差突破历史均值 +1.5σ:买入现券 + 付固定

  • 利差跌破历史均值 −1.5σ:卖出(融券)现券 + 收固定

平仓逻辑:

  • 多债(空利差)仓位:利差回落至均值 +0.3σ 以内时平仓

  • 空债(多利差)仓位:利差回升至均值 −0.3σ 以内时平仓

4.1. 编写自定义策略

首先基于分钟行情定义技术指标:利差的滚动均值与标准差、久期估计、互换手数推算。示例如下:

def calcSpreadStats(spreadList, lookback){
    out = dict(STRING, ANY)
    // 默认未就绪;用 NULL 避免上层误用无效统计量。
    out["ready"] = false
    out["mu"] = NULL
    out["sigma"] = NULL
    // 历史样本不足时直接返回,不产生交易信号。
    if (size(spreadList) < lookback) return out
    // 计算历史均值及样本标准差,分母使用 lookback-1。
    mu = avg(spreadList)
    sig = sqrt(sum(pow(spreadList - mu, 2.0)) / (lookback - 1.0))
    out["ready"] = true
    out["mu"] = mu
    out["sigma"] = sig
    return out
}
// 将利率统一转换为小数形式。
// 例如 2.5 被视为 2.5%,转换为 0.025;0.025 已是小数形式,保持不变。
def toRate(x){
    if (isNull(x)) return NULL
    return iif(double(x) > 0.5, double(x) \ 100.0, double(x))
}
// 使用固定利率年金近似 IRS 固定端的修正久期。
// rate:IRS 固定端利率;years:互换期限;freq:每年付息次数。
// 当利率无效或非正时,使用 years*0.85 作为保守近似值。
def approxSwapModDur(rate, years, freq){
    r = toRate(rate)
    f = double(freq)
    // 总付息期数,例如 5 年、季付对应 20 期。
    n = double(years) * f
    c = r / f
    if (c <= 0.0) return double(years) * 0.85
    return (1.0 - pow(1.0 + c, -n)) / r
}
// 基于两腿名义本金和修正久期进行近似 DV01 配平,返回 IRS 整数手数。
// 由于 DV01 中共同的 1bp 系数会抵消,手数比可直接用“名义本金*久期”计算。
def calcIrsQtyByDv01(bondQty, bondMult, bondDur, irsMult, irsDur){
    // 久期缺失时退化为 1 手,保证示例仍可继续运行。
    if (isNull(bondDur) or isNull(irsDur) or bondDur <= 0.0 or irsDur <= 0.0) return 1l
    // 现券腿实际名义本金。
    nBond = double(bondQty) * double(bondMult)
    // 根据两腿久期比例计算 IRS 目标名义本金。
    nIrs = nBond * double(bondDur) / double(irsDur)
    // 除以 IRS 合约乘数并四舍五入为整数手数。
    q = long(floor(nIrs / double(irsMult) + 0.5))
    // 至少交易 1 手,避免计算结果被取整为 0。
    if (q < 1) q = 1
    return q
}

在策略初始化函数中设置合约、手数、信号阈值及债券/互换条款等参数:

def initialize(mutable context){
    // initialize 在回测引擎启动时调用一次,负责初始化策略参数。
    // ---------- 1. 交易标的与信号参数 ----------
    // 银行间国债代码;“.T1”表示本例使用的结算方式后缀。
    context["bondSym"] = "230021.T1"
    // 5 年期、以 FR007 为浮动端基准的利率互换合约。
    context["irsSym"] = "FR007_5Y"
    // 每次债券开仓数量(面额单位);IRS 数量由 DV01 配平动态计算。
    context["Lot"] = 1000000l
    // 滚动窗口长度:累计 380 个同步分钟利差后才允许产生交易信号。
    context["lookback"] = 380
    // 开仓阈值为均值上下 1.5 倍标准差。
    context["entryZ"] = 1.5
    // 平仓阈值为均值上下 0.3 倍标准差。
    context["exitZ"] = 0.3
    // ---------- 2. 最新行情缓存 ----------
    // 债券收盘净价、债券到期收益率和 IRS 固定端利率;收到行情前均为 NULL。
    context["bondClose"] = NULL
    context["bondYtm"] = NULL
    context["irsRate"] = NULL
    // 历史同步利差窗口;只保存最近 lookback 个观测。
    context["spreadList"] = array(DOUBLE, 0)
    // 记录债券和 IRS 最新一根 K 线时间,用于保证两腿数据严格同步。
    context["bondFreshDt"] = NULL
    context["irsFreshDt"] = NULL
}

每个交易日开盘前重置当日行情缓存:

def beforeTrading(mutable context){
    // beforeTrading 在每个交易日开始时调用。
    // 清空两腿“当日最新行情时间”,防止新交易日误用上一日的缓存时间配对。
    // 历史 spreadList 不清空,使滚动统计窗口能够跨交易日延续。
    context["bondFreshDt"] = NULL
    context["irsFreshDt"] = NULL
}

在 onBar 中实现:双边分钟对齐 → 更新利差与 Carry 累计 → 按 σ 带宽开平仓,并在开仓时按久期计算互换手数:

  • 利差突破 μ±1.5σ 时的开仓,以及回落至 μ±0.3σ 内时的平仓判断逻辑;

  • 基于债券修正久期与互换近似修正久期计算 IRS 对冲手数的实现方式。

def onBar(mutable context, data1){
    // onBar 是策略核心回调。data1 为本次到达的一根分钟 K 线,可能来自债券或 IRS。
    // 两种标的共用同一个回调,通过 symbol 判断并更新各自的最新行情缓存。
    sym = data1.symbol
    dt = data1.datetime

    // ---------- step 1. 更新债券或 IRS 最新行情 ----------
    if (sym == context["bondSym"]){
        // 债券 close 用于订单定价,closeYTM 用于计算与 IRS 的收益率利差。
        context["bondClose"] = data1.close
        ytm = data1.closeYTM
        context["bondYtm"] = ytm
        context["bondFreshDt"] = dt
    } else if (sym == context["irsSym"]){
        // IRS close 表示本分钟固定端利率,同时作为订单价格使用。
        context["irsRate"] = data1.close
        context["irsFreshDt"] = dt
    }

    // ----------step 2. 校验两腿行情是否齐备且时间完全同步 ----------
    // 任意一腿尚未到达时返回,等待另一腿同一时间戳的 K 线。
    if (isNull(context["bondFreshDt"]) or isNull(context["irsFreshDt"])) return
    // 要求债券和 IRS 的最新时间都等于当前回调时间,防止新旧 K 线错配。
    if (context["bondFreshDt"] != dt or context["irsFreshDt"] != dt) return

    // ---------- step 3. 计算当前利差并读取实际持仓 ----------
    // 当前债券收盘价用于下单;利差统一定义为“债券 YTM - IRS 固定端利率”。
    px = context["bondClose"]
    spread = context["bondYtm"] - context["irsRate"]
    bond = context["bondSym"]
    irs = context["irsSym"]
    // 从回测引擎读取两腿真实持仓,不仅依赖策略内部标志。
    posB = Backtest::getPosition(context["engine"], bond)
    posI = Backtest::getPosition(context["engine"], irs)
    // 分别取得债券和 IRS 的多头、空头数量,用于判断开平仓状态。
    longB = long(posB.longPosition)
    shortB = long(posB.shortPosition)
    longI = long(posI.longPosition)
    shortI = long(posI.shortPosition)

    // ----------step 4. 使用历史窗口计算动态阈值 ----------
    // 当前 spread 尚未加入 spreadList,因此阈值只依赖此前已完成的观测。
    st = calcSpreadStats(context["spreadList"], context["lookback"])
    if (st["ready"]){
        mu = st["mu"]
        sig = st["sigma"]
        // 上下开仓线:均值 ± 1.5σ。
        upEntry = mu + context["entryZ"] * sig
        loEntry = mu - context["entryZ"] * sig
        // 上下平仓线:均值 ± 0.3σ,形成比开仓区间更窄的退出区间。
        upExit  = mu + context["exitZ"] * sig
        loExit  = mu - context["exitZ"] * sig

        // 债券目标数量和 IRS 当前固定端利率。
        lot = context["Lot"]
        irsPx = context["irsRate"]

        // ---------- step 5. 优先执行已有组合的平仓逻辑 ----------
        // step  5.1 当前持有债券多头时,代表此前在高利差区间执行了“买债+付固定”。
        // 当利差回落至上侧退出线以下,卖出债券并平掉付固定 IRS。
        if (longB > 0 and spread < upExit){
            // 债券:direction=2 卖出,openClose=2 平仓,数量使用全部实际多头。
            Backtest::submitOrder(context["engine"],
                dict(`symbol`source`qty`orderType`direction`openClose`price,
                    (bond, "AGG", longB, 5, 2, 2, double(px))), "卖平债")
            // IRS:付固定在本例中对应多头;direction=2 用于反向平仓。
            if (longI > 0)
                Backtest::submitOrder(context["engine"],
                    dict(`symbol`source`qty`orderType`direction`price,
                        (irs, "XSWAP", longI, 5, 2, double(irsPx))), "平付固")
        }
        // step 5.2 当前持有债券空头时,代表此前在低利差区间执行了“卖债+收固定”。
        // 当利差回升至下侧退出线以上,买回债券并平掉收固定 IRS。
        else if (shortB > 0 and spread > loExit){
            // 债券:direction=1 买入,openClose=2 平仓,数量使用全部实际空头。
            Backtest::submitOrder(context["engine"],
                dict(`symbol`source`qty`orderType`direction`openClose`price,
                    (bond, "AGG", shortB, 5, 1, 2, double(px))), "买平债")
            // IRS:收固定在本例中对应空头;direction=1 用于反向平仓。
            if (shortI > 0)
                Backtest::submitOrder(context["engine"],
                    dict(`symbol`source`qty`orderType`direction`price,
                        (irs, "XSWAP", shortI, 5, 1, double(irsPx))), "平多利差-平收固")
        }
        // ----------step 6. 仅在两腿完全空仓时检查新开仓信号 ----------
        // 该条件防止已有组合尚未平仓时重复加仓或同时持有相反方向。
        else if (longB < 1 and shortB < 1 and longI < 1 and shortI < 1){
            // 只有当前利差突破任一开仓边界时,才计算久期和 IRS 对冲数量。
            if (spread > upEntry or spread < loEntry){
                // 将债券 YTM 转成小数形式。
                bytm = toRate(context["bondYtm"])
                // bondDuration 返回债券麦考利久期;日期、票息、频率和 YTM 来自参考数据及行情。
                macD = bondDuration(context["bondStart"], context["bondMaturity"], context["bondIssuePrice"],
                    context["bondCoupon"], context["bondFreq"], "ActualActualISMA", "FixedRate",
                    date(dt), bytm, "YTM")
                // 麦考利久期转换为修正久期,用于近似债券 DV01。
                Db = macD / (1.0 + bytm / double(context["bondFreq"]))
                // 本例假设 IRS 期限为 5 年、固定端按季支付,每年 4 次。
                Ds = approxSwapModDur(irsPx, 5.0, 4)
                // 根据两腿修正久期和合约乘数,将债券数量换算为 IRS 整数手数。
                irsLot = long(calcIrsQtyByDv01(context["Lot"], context["bondMult"], Db, context["irsMult"], Ds))

                // step 6.1 利差高于上侧开仓线:买入债券,同时在 IRS 上付固定。
                // 买债提供正久期,付固定提供负久期,形成近似 DV01 中性的组合。
                if (spread > upEntry){
                    Backtest::submitOrder(context["engine"],
                     dict(`symbol`source`qty`orderType`direction`openClose`price,
                            (bond, "AGG", lot, 5, 1, 1, double(px))), "买债")
                    Backtest::submitOrder(context["engine"],
                        dict(`symbol`source`qty`orderType`direction`price,
                            (irs, "XSWAP", irsLot, 5, 1, double(irsPx))), "付固定")
                }
                //step 6.2 利差低于下侧开仓线:融券卖出债券,同时在 IRS 上收固定。
                // 卖债提供负久期,收固定提供正久期,形成反向配对组合。
                else if (spread < loEntry){
                    Backtest::submitOrder(context["engine"],
                     dict(`symbol`source`qty`orderType`direction`openClose`price,
                            (bond, "AGG", lot, 5, 2, 1, double(px))), "卖债")
                    Backtest::submitOrder(context["engine"],
                        dict(`symbol`source`qty`orderType`direction`price,
                            (irs, "XSWAP", irsLot, 5, 2, double(irsPx))), "收固定")
                }
            }
        }
    }

    // 价差数据
    context["spreadList"].append!(spread)
    // 窗口超过 lookback 时只保留尾部最近 lookback 个价差数据。
    if (size(context["spreadList"]) > context["lookback"])
        context["spreadList"] = tail(context["spreadList"], context["lookback"])
    // 清空同步时间,确保下一次计算必须重新收到债券和 IRS 同时间戳行情。
    context["bondFreshDt"] = NULL
    context["irsFreshDt"] = NULL
}

利率互换下单时,submitOrder 不需要 openClose 字段,只需指定交易方向 direction:付固定(direction = 1)与收固定(direction = 2);现券订单仍需同时给出 direction 与 openClose。

4.2. 根据策略设置相应的配置参数

本案例回测配置示例如下:策略组为 FICC,使用 OHLC(dataType=1),启用债券借贷,并输出订单信息:

config = {
    // 回测起止日期。
    startDate: begt,
    endDate: endt,
    // 债券与 IRS 属于固收品种,使用 FICC 策略组。
    strategyGroup: "FICC",
    // 初始资金 10 亿元。
    cash: 1000000000.0,
    // dataType=1 表示使用 OHLC K 线行情驱动 onBar。
    dataType: 1,
    // matchingMode=1 使用本例对应的撮合模式。
    matchingMode: 1,
    // 策略只接收指定债券和 5 年期 FR007 IRS 的行情。
    universe: [["230021.T1", "FR007_5Y"]],
    // 允许债券卖空,反向套利依赖此配置。
    enableBondLending: true,
    // 输出订单状态,便于回测结束后筛选有效成交。
    outputOrderInfo: true,
    //从合约参考表读取估值和对冲参数
    context:{
    	// // IRS 每手代表的名义本金,用于将目标 IRS 名义本金换算为合约手数。
    	irsMult: double((exec multiplier from xswapRef)[0]),
    	 // 债券年付息次数、起息日、到期日、发行价和乘数,用于计算久期与名义本金。
	bondFreq: int((exec frequency from bondRef)[0]),
	bondStart: date((exec valueDate from bondRef)[0]),
	bondMaturity:date((exec maturityDate from bondRef)[0]),
	bondIssuePrice: double((exec issuePrice from bondRef)[0]),
	bondMult:double((exec multiplier from bondRef)[0]),
	 // 票面利率统一转换为小数形式,供 bondDuration 使用。
	bondCoupon: toRate((exec couponRate from bondRef)[0])	 	
    }
}

4.3. 创建引擎

利率互换策略 irs 的 securityReference 需设置三张基础信息表,分别是 xswap 合约条款表、swapCurve 利率曲线与 swapAssetPriceHistCurve 浮动基准历史定盘,债券的 securityReference 的 key 为 xbond:

// key 必须与插件识别的资产类别一致。
securityReference ={
	xbond: bondRef,
	xswap:xswapRef,
	swapCurve: swapCurve,
	swapAssetPriceHistCurve:swapAssetPriceHistCurve
}

配置引擎,插入行情并执行回测:

callbacks = {
    initialize: initialize,
    beforeTrading: beforeTrading,
    onBar: onBar,
    afterTrading: afterTrading
}
strategyName = "ASW_basis_xswap"
try{ Backtest::dropBacktestEngine(strategyName) }catch(ex){ print(ex) }
engine = Backtest::createBacktester(strategyName, config, callbacks, false, securityReference)
msg = dict(STRING, ANY)
// 按时间升序回放,确保滚动窗口和两腿时间同步判断正确。
msg["ohlc"] = select * from ohlcData order by datetime
// 送入全部分钟行情并触发策略回调。
Backtest::appendQuotationMsg(engine, msg)
// 追加结束标记,触发最后结算并结束回测生命周期。
Backtest::appendEndMarker(engine)

4.4. 查看回测结果

// orderStatus 0/1 对应本例关注的有效订单/成交状态。
tradeDetails = select * from Backtest::getTradeDetails(engine) where orderStatus in [0,1]
// 读取组合层面的资金、持仓市值和累计损益。
totalpnl = Backtest::getTotalPortfolios(engine)
// 读取总收益、年化收益、波动率、夏普率和最大回撤等绩效指标。
dailyTotalPortfolios = Backtest::getReturnSummary(engine)

本例基于引擎接口函数 getReturnSummary 输出的累计收益、年化收益、最大回撤、夏普比率。

5. 策略评价

为了直观地评估 DolphinDB FICC 回测插件在中高频场景下的执行性能,我们基于以上三个案例进行测试:

5.1. XBOND 交易策略

选取 10 年国债 XBOND 在 10 个交易日内的完整市场快照行情(共 5491 条)、分钟行情(共 1137 条)和成交行情(共 100 条),生成 7 笔成交订单,回测整体耗时 0.7 s。

5.2. 做市双边策略及平盘策略

选取做市 FIESP 快照行情(共 2168 条),非做市 XBOND 快照行情(共 2910 条),在本次回测中产生提交双边报价、撤销报价重新上报等共 38 条订单,整体耗时 0.4 s。

5.3. 债券和利率互换套利策略

选取 5 年期国债活跃券与 5 年期 IRS 的分钟级行情(共 2535 条数据),在本次回测中,生成 6 条成交订单,在单线程、非 JIT 模式下整体耗时 4 s。

6. 总结

在 FICC 量化策略的实际应用中,交易标的常横跨债券现券、利率互换、外汇及大宗商品,单一资产回测难以刻画保证金动态、跨品种风险传导以及资金成本对组合收益的真实影响。本文以 XBOND 现券日内交易、做市双边报价与平盘、债券–IRS 基差套利三个典型场景为例,系统呈现了 DolphinDB 多资产回测框架在统一引擎内融合多品种行情驱动、账户管理和调仓执行的全链路流程。该框架支持快照、分钟级、逐笔成交等多路行情灵活接入,并通过差异化撮合规则和专用下单接口,精准模拟现券买卖、双边报价及跨品种对冲操作;同时,统一的绩效评估模块可对策略进行多维事后分析。相较传统分资产回测方案,DolphinDB 不仅显著降低了 FICC 策略落地的工程复杂度,在中高频场景下仍能保持秒级回放效率,并完整保留逐笔交易细节,为固收及衍生品策略的验证与实盘部署提供了高可扩展的一体化平台。