股票中低频投资组合回测案例实现

首先在执行回测逻辑前采用 MyTT 模块预先计算如下指标，计算完毕后合并至分钟行数数据库表 messageTable 的 signal列 （完整脚本可参考附件 loadData1.dos）。

1. 计算个股的短期均线 shortMA 和长期均线 longMA 用于判断趋势信号，通过均线交叉识别买入或卖出的时机。

   use mytt
   // 短期均线
   def getShortTermMA(close, period=5){
       return MA(close, period)
   }
   // 长期均线
   def getLongTermMA(close, period=20){
       return MA(close, period)
   }

2. 利用 prev 函数获取个股的前一期短期均线 prevShortMA 和长期均线 prevLongMA，用于判断是否有均线交叉。

   update facTable set prevShortMA = prev(shortMA).bfill(), 
                       prevLongMA = prev(longMA).bfill()

3. 计算个股的相对强弱指标RSI用于评估超买或超卖状态，帮助控制买卖时的市场情绪风险。

   use mytt
   def getRSI(close, N = 24){
       return RSI(close, N = 24) //直接调用mytt的 RSI 函数
   }

4. 计算个股的波动率 volatility 用于衡量价格的波动幅度，提供风控依据以避免高风险资产对组合的不利影响。

   use mytt
   def getVolatility(close, period=10){
       returns = DIFF(close) / REF(close, 1)
       return STD(returns, period)
   }

5. 交易状态判断。自定义 checkTradingStatus 函数，在发送个股交易信号前，先通过该函数判断个股交易状态是否异常，若存在停牌、涨跌停等异常情况，则不进行交易。

   def checkTradingStatus(
       open, high, 
       low, volume, 
       turnover, close, 
       upLimitPrice, downLimitPrice
   ){
       // 检查是否停牌
       isHalted = (open==0 || high==0 || low==0 || volume==0 || turnover==0)
       
       // 检查是否涨跌停
       isPriceLimited = (close>=upLimitPrice || close<=downLimitPrice)
       
       // 返回交易状态
       return iif(isHalted || isPriceLimited, 0, 1)
   }

回测的开始与结束日期、初始资金、行情类型等均可以通过该参数进行配置。这些参数允许用户灵活地调整回测条件，以模拟不同的市场环境和交易策略的效果。具体的初始参数配置代码示例如下，其中详细回测参数配置要求可参考引擎配置说明文档。

config=dict(STRING,ANY) // 以字典形式存储回测参数     
config["startDate"]= 2024.01.01 // 设置回测开始时间
config["endDate"]= 2024.12.31 // 设置回测结束时间

config["strategyGroup"] = "stock" // 选择回测模式，本案例中为股票模式
config["frequency"] = 0 // 指定逐笔数据合成快照的频率
config["cash"] = 10000000.        // 初始资金,1000万
config["commission"] = 0.0005  // 交易佣金
config["tax"] = 0.0      // 忽略税
config["dataType"] = 3 // 分钟频
config["matchingMode"] = 3 // 选择交易模式，本案例以委托价格成交
config["msgAsTable"] = false // 以字典形式传入行情数据

// 设置逻辑全局上下文
config["context"] = dict(STRING,ANY)
context = dict(STRING,ANY)
context["activeTime"] = 14:30m // 设置每天交易时间
context["maxPosition"] = 0.1 // 设置单只股票最大持仓比例
context["minPosition"] = 0.001 // 设置单只股票最小持仓比例
config["context"] = context

1. 设置辅助函数

辅助函数主要用于支持 onBar函数中的核心逻辑实现，处理买卖单生成、每日持仓更新等功能。

• getSellVolume：计算卖出量，确保股数符合交易规则。

  def getSellVolume(price, value, position){
      // 若卖出=持仓,清仓;小于持仓,按照100的倍数卖出
      // 此处/代表整除
      vol = int(value/price)/100*100
      // 确保卖出的股数为100倍
      return int(iif(vol < position, vol , position))
  }

• getBuyVolume：计算买入量，确保符合不同股票交易规则（科创板需为 200 的倍数，其他为 100 的倍数）。

  def getBuyVolume(symbol, price, value){
      // 若symbol以688开头,则需要是200的倍数;否则是100的倍数
      vol = int(value/price)
      return int(iif(symbol like "688%",vol/200*200, vol/100*100))
  }

• executeSellOrders：根据策略逻辑提交卖单。
  • 首先判断标的是否停牌或涨跌停，若均没有则可交易。
  • 其次调用 Backtest::getPosition 接口获取标的现有持仓量，从 msg 行情字典提取标的收盘价，并从 sellDeltaValueDict 提取标的现有持仓市值和预期市值的差异。
  • 根据现有持仓市值和预期市值的差异计算需要卖出的数量，并提交卖单执行卖平操作。

  def executeSellOrders(mutable context, msg, sellDeltaValueDict, 
      sellSymbol, label="SellClose"){
      /* 卖出函数
      @Parameters
      ---------------------
      context: `DICT`
          回测上下文
      msg: `DICT`
          行情数据
      sellDeltaValueDict: `DICT`
          待卖出股票的持仓变化值
      sellSymbol: `STRING`
          待卖出股票代码
      label: `STRING`
          卖出订单标识，用于区分不同卖出场景
      */
   
  
      // 判断是否停牌或涨跌停，若满足条件则跳过
      &tradeFlag = checkTradingStatus(
          msg[sellSymbol]["open"],
          msg[sellSymbol]["high"],
          msg[sellSymbol]["low"],
          msg[sellSymbol]["volume"],
          msg[sellSymbol]["signal"][0],
          msg[sellSymbol]["close"],
          msg[sellSymbol]["upLimitPrice"],
          msg[sellSymbol]["downLimitPrice"]
      )
      if (tradeFlag == 1){
          // 获取持仓信息
          &pos = Backtest::getPosition(context["engine"], sellSymbol)["longPosition"]
          if (pos == NULL){
              pos = 0.0
          }
          &price = msg[sellSymbol]["close"]
          &value = abs(sellDeltaValueDict[sellSymbol])
          
          // 计算需要卖出的股数
          &sellVolume = getSellVolume(price, value, pos)
          if (pos > 0 and sellVolume > 0) {
              Backtest::submitOrder(context["engine"], 
                 (sellSymbol, context["tradeTime"], 5, price, sellVolume, 3), label)
          }
  
      }
       
  }

• executeBuyOrders：根据策略逻辑提交买单。
  • 首先判断标的是否停牌或涨跌停，若均没有则可交易。
  • 其次调用 Backtest::getPosition 接口获取标的现有持仓量，从 msg 行情字典提取标的收盘价，并从 buyDeltaValueDict 提取标的现有预期市值和持仓市值的差异。
  • 根据现有预期市值和持仓市值的差异计算需要买入的数量，并提交买单执行买开操作。

  def executeBuyOrders(mutable context, msg, buyDeltaValueDict, 
      buySymbol, label="BuyOpen"){
      /*买入函数
          @Parameters
          ---------------------
          context: `DICT`
              回测上下文
          msg: `DICT`
              行情数据
          buyDeltaValueDict: `DICT`
              待买入股票的持仓变化值
          buySymbol: `STRING`
              待买入股票代码
          label: `STRING`
              买入订单标识，用于区分不同买入场景
      */
      // 判断是否停牌或涨跌停，若满足条件则跳过
      &tradeFlag = checkTradingStatus(
          msg[buySymbol]["open"],
          msg[buySymbol]["high"],
          msg[buySymbol]["low"],
          msg[buySymbol]["volume"],
          msg[buySymbol]["signal"][0],
          msg[buySymbol]["close"],
          msg[buySymbol]["upLimitPrice"],
          msg[buySymbol]["downLimitPrice"]
      )
      if (tradeFlag == 1){
          // 获取可用资金
          &cash = Backtest::getTotalPortfolios(context["engine"])["cash"][0]
          &price = msg[buySymbol]["close"]
          &value = buyDeltaValueDict[buySymbol]
          
          // 计算转换前的数量
          &buyVolume = getBuyVolume(buySymbol, price, min(cash, value))
          
          // 检查可用资金是否足够，若不足则退出函数
          if (cash < buyVolume * price * (1 + context["commission"])) return
  
          if (buyVolume > 0) {
              Backtest::submitOrder(context["engine"], 
              (buySymbol, context["tradeTime"], 5, price, buyVolume, 1), label)
          }
  
      }
  
  }
  

• sortDict ：对字典根据value值进行排序

  def sortDict(x, ascending=true){
      // 对字典排序
      x_idx = isort(x.values(), ascending)
      res = dict(x.keys()[x_idx], x.values()[x_idx],true)
      return res
  }

2. 设置策略回调函数

(1) 回测初始化函数 initialize

该函数在回测开始时触发调用，用户可在此函数中直接设置全局变量。

def initialize(mutable context){
    //初始化回调函数
    print("initialize")
}

(2) 盘中回调交易函数 onBar

本策略根据市场条件和风控规则优化持仓结构。在每分钟触发的交易回调中，该模式首先判断当前时间是否为指定的交易分钟，若到了交易分钟，则进入交易逻辑，对当前市场数据和历史持仓状态进行全面分析，筛选出符合买入但不符合剔除条件的股票，并在回测过程中动态调整仓位权重，构建出最终的建仓投资组合。

核心特点：

• 集中建仓：用于初始建仓阶段，对未持仓的股票筛选和分配权重。
• 买入逻辑：短期均线上穿长期均线或 RSI < 70。
• 剔除逻辑：短期均线下穿长期均线或 RSI > 80。
• 权重分配：根据筛选出的股票数量进行初始权重分配，权重设置为 1\股票数量。
• 风控管理：
  • 降低波动率高的股票权重：
    • 0.005 < 波动率 < 0.01 时权重变为原来的 0.5。
    • 波动率 > 0.01 时权重变为原来的 0.1。
  • 限制单只股票的权重在最小和最大持仓比例之间。
• 权重归一化：确保总权重为 1。
• 持仓调整：
  • 根据当前持仓和预期市值的差异进行卖出或买入操作。
  • 优先处理卖出逻辑，再执行买入逻辑。

交易逻辑：

• 检查是否为交易时间。首先检查当前时间是否为预设的交易时间（activeTime），如果不是交易时间，直接返回，避免不必要的运算。

  if (context["activeTime"] != minute(context["tradeTime"])) {// 非交易分钟直接返回
      return
  }

• 初始化信号和列表。初始化两个列表，buyList（买入列表）和 deleteList（剔除列表），分别用于存储符合买入条件的股票和符合剔除条件的股票。

  // 初始化
  &buyList = array(SYMBOL)
  &deleteList = array(SYMBOL)

• 遍历每只股票，计算买卖信号，筛选出待买和待卖标的。
  • 待买标的buyList：短期均线向上穿越长期均线（getCross 返回 [True, False]）或 RSI < 70，如果满足上述条件且交易状态正常，将该股票加入 buyList。
  • 待剔除标的deleteList：短期均线向下穿越长期均线（getCross 返回 [False, True]）或 RSI > 80，如果满足上述条件且交易状态正常，将该股票加入 deleteList。

  for (istock in msg.keys()){
      &istock = istock
      &pos = Backtest::getPosition(context["engine"], istock)["longPosition"]
      &price = msg[istock]["close"]
      &tradeFlag = checkTradingStatus(msg[istock]["open"], 
                                      msg[istock]["high"], 
                                      msg[istock]["low"], 
                                      msg[istock]["volume"], 
                                      msg[istock]["signal"][0], 
                                      msg[istock]["close"], 
                                      msg[istock]["upLimitPrice"], 
                                      msg[istock]["downLimitPrice"])
      
      // 买入逻辑：短期均线上穿长期均线，或 RSI < 70
      if (getCross(msg[istock]["signal"][3], msg[istock]["signal"][2], 
                   msg[istock]["signal"][6], msg[istock]["signal"][5])[0] 
                   or msg[istock]["signal"][1] < 70 
                   and tradeFlag) {
          buyList.append!(istock)
      }
  
      // 剔除逻辑：短期均线下穿长期均线，或 RSI > 80
      if (getCross(msg[istock]["signal"][3], msg[istock]["signal"][2], 
                   msg[istock]["signal"][6], msg[istock]["signal"][5])[1] 
                   or msg[istock]["signal"][1] > 80 
                   and tradeFlag) {
          deleteList.append!(istock)
      }
  }

• 筛选出最终投资组合列表并进行个股风控。
  • 剔除满足剔除条件的股票，得到需要重点关注的股票列表 posList 为最终投资组合列表。
  • 初始化每只股票的权重为等权分配（1\股票数量）。
  • 根据波动率和 RSI 指标调整权重：0.005 < 波动率 < 0.01 时权重变为原来的 0.5，波动率 > 0.01 时权重变为原来的 0.1，记录风控状态； RSI 指标<70时，风控解除。
  • 个股权重限制在 maxPosition 和 minPosition 范围内。

  // 筛选满足买入条件后没有满足剔除条件的股票，对该股票池进行操作
  &posList = (set(buyList) - set(deleteList)).keys()
  
  if (count(posList) != 0) {
      // 新建权重字典
      weightDict = dict(SYMBOL,DOUBLE)
      for (istock in posList) {
          // 先初始化权重, 1\股票数量
          weightDict[istock] = 1 \ posList.size()
  
          // 个股风控
          &volatility = msg[istock]["signal"][4]
          &RSI = msg[istock]["signal"][1]
          // 风控重置逻辑
          if (context["riskDict"][istock] == 1 && RSI < 70) {
              context["riskDict"][istock] = 0  // 风控状态置为 0
          }
          // 个股风控逻辑：限制波动率超标的权重
          if (0.005 < volatility < 0.01) {
              weightDict[istock] *=  0.5  // 降低波动率高的股票的权重
              context["riskDict"][istock] = 1  // 风控状态置为 1
          }
          else if (volatility > 0.01) {
              weightDict[istock] *=  0.1  // 降低波动率高的股票的权重
              context["riskDict"][istock] = 1  // 风控状态置为 1
          }
  
          // 限制单只股票的最大和最小持仓比例
          weightDict[istock] = min(weightDict[istock], context["maxPosition"])
          weightDict[istock] = max(weightDict[istock], context["minPosition"])
  
      }

• 个股权重归一化。

  进行个股权重归一化，使所有个股权重的总和等于 1，保证所有资金被合理分配到投资组合中的每只股票。

  // 个股权重归一化
  weightSum = sum(weightDict.values())
  if (weightSum != 0) {
      for (istock in posList) {
          weightDict[istock] /= weightSum
      }
  } 

• 根据预期市值和现有持仓市值计算持仓市值变化。
  • 创建预期市值、持仓市值、卖出差值字典、买入差值字典，分别用于存储各标的的预期市值、现有持仓市值、待卖股票持仓市值变化、待买股票持仓市值变化。
  • 首先调用 Backtest::getTotalPortfolios 接口，获取当前账户总权益，得到账户持仓总市值和可用资金，并结合各标的权重算出预期市值。
  • 其次调用 Backtest::getPosition 接口，获取各标的现有持仓量，结合收盘价计算出现有持仓市值。
  • 最后比较预期市值和持仓市值：
    • 预期市值 < 持仓市值，则加入待卖字典。
    • 预期市值 > 持仓市值，则加入待买字典。

  // 新建预期市值、持仓市值、deltaValue字典
  expectValueDict = dict(SYMBOL,DOUBLE)
  positionValueDict = dict(SYMBOL,DOUBLE)
  sellDeltaValueDict = dict(SYMBOL,DOUBLE)
  buyDeltaValueDict = dict(SYMBOL,DOUBLE)
  
  // 获取净资产
  &equity = Backtest::getTotalPortfolios(context["engine"])["totalEquity"][0]
  
  // 计算预期市值和持仓市值
  for (istock in posList) {
      ExpectValue = equity * weightDict[istock]
      expectValueDict[istock] = ExpectValue
      // 使用 Backtest::getPosition 获取每日持仓信息
      longPosition = Backtest::getPosition(context["engine"], istock)["longPosition"]
  
      if (longPosition == NULL) {
          positionValue = 0.0
      } else {
          positionValue = longPosition * msg[istock]["close"]
      }
      positionValueDict[istock] = positionValue
      deltaValue = ExpectValue - positionValue
      if (deltaValue > 0) {
          buyDeltaValueDict[istock] = deltaValue
      } else if (deltaValue < 0) {
          sellDeltaValueDict[istock] = deltaValue
      }
  }

• 遍历待卖字典和待买字典，根据预期市值和现有持仓市值的差异绝对值从大到小卖出和买入。

  // 卖出逻辑
  sellSymbol = sellDeltaValueDict.keys()
  
  if (count(sellSymbol) != 0) {
      sortedSellDeltaValueDict = sortDict(sellDeltaValueDict, true)//字典排序
      sortedSellSymbol = sortedSellDeltaValueDict.keys()
      // 遍历卖出列表，卖出股票
      for (istock in sortedSellSymbol) {
          executeSellOrders(context, msg, sortedSellDeltaValueDict, istock)
          // 更新持仓信息
          longPosition = Backtest::getPosition(context["engine"], 
                                               istock)["longPosition"]
          if (longPosition == NULL) {
              positionValue = 0.0
          } else {
              positionValue = longPosition * msg[istock]["close"]
          }
          positionValueDict[istock] = positionValue
      }
  
  }
  
  // 买入逻辑
  buySymbol = buyDeltaValueDict.keys()
  
  if (count(buySymbol) != 0) {
      sortedBuyDeltaValueDict = sortDict(buyDeltaValueDict, false) // 字典排序
      sortedBuySymbol = sortedBuyDeltaValueDict.keys()
  
      // 遍历买入列表，买入股票
      for (istock in sortedBuySymbol) {
          executeBuyOrders(context, msg, sortedBuyDeltaValueDict, istock)
          // 更新持仓信息
          longPosition = Backtest::getPosition(context["engine"], 
                                               istock)["longPosition"]
          if (longPosition == NULL) {
              positionValue = 0.0
          } else {
              positionValue = longPosition * msg[istock]["close"]
          }
          positionValueDict[istock] = positionValue
      }
      
  }

调用 Backtest::createBacktester 创建回测引擎，参数为引擎名称和各事件函数。详情可参考文档接口说明。

strategyName="StockBackTest"
callbacks = dict(STRING, ANY)
callbacks["initialize"] = initialize
callbacks["beforeTrading"] = beforeTrading
callbacks["onBar"] = onBar
callbacks["onTick"] = onTick
callbacks["onOrder"] = onOrder
callbacks["onTrade"] = onTrade
callbacks["afterTrading"] = afterTrading
callbacks["finalize"] = finalize
try{Backtest::dropBacktestEngine(strategyName)}catch(ex){print ex}
engine = Backtest::createBacktester(strategyName, config, callbacks,true, )

通过 Backtest::createBacktester 创建回测引擎之后，可以通过以下方式将行情数据传入回测引擎，执行回测。messageTable 为相应的行情数据，以字典格式传入，行情数据字段和类型说明可参考文档Backtest。

timer Backtest::appendQuotationMsg(engine,messageTable)
 
a = select * from messageTable where tradeTime=max(tradeTime) limit 1
update a set symbol = "END"
Backtest::appendQuotationMsg(engine, a) // 字典结构

调用Backtest::getTradeDetails(engine)、Backtest::getDailyTotalPortfolios(engine)、getReturnSummary(long(engine)) 等接口可以查看对应回测结果，如检查退单情况、查看投资组合总体情况、查看回报情况等。具体接口的返回结果可参考接口说明文档接口说明。

// 获取交易详情
select * from Backtest::getTradeDetails(engine) where orderStatus==1 

// 检查退单情况
select * from Backtest::getTradeDetails(engine) where orderStatus==-1 

// 查看投资组合总体情况
dailyTotalPortfolios=Backtest::getDailyTotalPortfolios(engine)

// 查看回报情况
returnSummary=Backtest::getReturnSummary(long(engine))

1. 初始化函数

首先，可以在初始化函数 initialize 中通过参数逻辑上下文 context 设置策略参数。策略初始化函数 initialize 只在创建引擎之后触发一次。在本案例中，须在初始化函数中通过 subscribeIndicator 实时订阅双均线、RSI、波动率等指标，并在初始化函数中定义买入、卖出信号阈值、个股信号、指数信号、双均线等全局参数。

def initialize(mutable contextDict){
    d = dict(STRING, ANY)
    d["shortMA"] = <MA(close, 5)>
    d["longMA"] = <MA(close, 20)>
    d["RSI"] = <RSI(close, 24)>
    d["volatility"] = <getVolatility(close, 10)>
    Backtest::subscribeIndicator(contextDict["engine"], "kline", d)
    
    // 买入信号阈值
    contextDict["buySignal"] = 0.995
    // 卖出信号阈值
    contextDict["sellSignal"] = 0.995
    // 信号字典
    contextDict["stockSignal"] = dict(STRING, ANY)
    contextDict["indexSignal"] = dict(STRING, ANY)
    // 短期均线长期均线的信号字典
    // 当短期均线大于长期均线更新为-1,当长期均线大于短期均线更新为1,其他标记为0
    contextDict["shortLongMA"] = dict(STRING, ANY)
}

2. 开仓信号判断

订阅得到上述指标后，在策略逻辑上下文 onBar 函数基于 shortMA、longMA 、RSI 、volatility 等指标，以及全局字典 shortLongMA 分别生成对应的开仓信号:

• 开盘时，当短均线穿过长均线、RSI 指标小于 70 且波动率因子 volatility 小于 0.02 生成多头信号，标记为 1。
• 开盘时，当长均线穿过短均线、或 RSI 指标大于 80 、或波动率因子 volatility 大于0.08 时，则生成空头信号，标记为 -1。

def onBar(mutable contextDict, msg, indicator){
    lowDict = contextDict["lowPrice"]
    highDict = contextDict["highPrice"]
    stockSignalDict = contextDict["stockSignal"] // 个股信号字典
    indexSignalDict = contextDict["indexSignal"] // 指数信号字典
    keysAll = msg.keys()
    
    // 先针对股票生成信号,假设只传入沪深300成分股+股指IF
    keys1 = keysAll[!(keysAll like "IF%")]
    for (i in keys1){
        &istock = msg[i].symbol
        &close = msg[i].close
        &shortMA = indicator[i].shortMA
        &longMA = indicator[i].longMA
        &RSI = indicator[i].RSI
        &volatility = indicator[i].volatility

        // 开仓信号
        if (minute(contextDict["tradeTime"])==09:31m){
            stockSignalDict[istock] = iif(
                contextDict[istock]==1 && shortMA>longMA && 
                RSI<70 && volatility<0.02, 
                1, 
                iif(
                    (contextDict[istock]==-1 && longMA>shortMA) || 
                    RSI>80 || volatility>0.05,
                    -1, 
                    0
                )
            )
        }
        
        // 记录收盘时刻下的短期均线和长期均线关系
        if (minute(contextDict["tradeTime"])==15:00m){
            shortLongMADict[istock] = iif(
                shortMA>longMA, 
                -1,
                iif(shortMA<longMA, 1, 0)
            )
        }

    //其他逻辑代码在下文展示，此处不再展示
}      

3. 平仓信号判断

当开盘生成个股开仓信号后，在策略逻辑上下文 onBar 函数基于个股分钟频收盘价 close、短均线指标 shortMA 分别生成对应的平仓信号：

• 多头：当收盘价跌破短均线，生成平仓信号，标记为0。
• 空头：当收盘价超过短均线，生成平仓信号，标记为0。

// 平仓信号
if (stockSignalDict[istock]==1){
    stockSignalDict[istock] = iif(close<shortMA, 0, stockSignalDict[istock])
}
else if (stockSignalDict[istock]==-1){
    stockSignalDict[istock] = iif(close>shortMA, 0, stockSignalDict[istock])
}

在生成得到成分股的信号以后，本案例以沪深300股指期货为例，在 onBar 函数中首先通过等权合成得到沪深300股指的信号 indexSignal ，基于该信号分别生成对应的开仓、平仓信号，并通过 Backtest::submitOrder 接口提交买入、卖出信号。

• 开仓信号：
  • indexSignal >0.75，则开多
  • indexSignal <-0.75，则开空
• 平仓信号：
  • 若开多且 indexSignal <0.25，则平仓
  • 若开空且 indexSignal >-0.25，则平仓

    // 股指合成逻辑
    keys2 = keysAll[keysAll like "IF%"]
    for (i in keys2){
        &index = msg[i].symbol
        &symbolSource = msg[i].symbolSource
        // 等权合成指数信号
        &indexSignal = stockSignalDict.values().sum()/300
        &price = msg[i].close
        if (indexSignal>0.75){
            // 标记开多信号
            indexSignalDict[index] = 1
            Backtest::submitOrder(contextDict["engine"], 
                      (index, symbolSource,contextDict["tradeTime"], 
                      5, price+0.02, 0., 2, 1, 0), "buyOpen")
        }   
        if (indexSignal<-0.75){
            // 标记开空信号
            indexSignalDict[index] = -1
            Backtest::submitOrder(contextDict["engine"], 
                    (index, symbolSource,contextDict["tradeTime"], 
                      5, price+0.02, 0., 2, 2, 0), "sellOpen")
    
        }
        if (indexSignalDict[index]==1 and indexSignal<0.25){
            // 平仓信号
            indexSignalDict[index] = 0
            Backtest::submitOrder(contextDict["engine"], 
                    (index, symbolSource,contextDict["tradeTime"], 
                    5, price-0.02, 0., 2, 3, 0), "sellClose")
        }
        if (indexSignalDict[index]==-1 and indexSignal<-0.25){
            // 平仓信号
            indexSignalDict[index] = 0
            Backtest::submitOrder(contextDict["engine"], 
                    (index, symbolSource,contextDict["tradeTime"], 
                    5, price-0.02, 0., 2, 4, 0), "buyClose")
        }    
    }