DolphinDB 回测平台与其它回测产品的对比分析

 def next(self):
    if self.order:
        return
    try:
        if not self.position:
                if (self.macd[0] > 0 and self.macd[1] < 0 
                  and self.rsi[0] > 30 and self.rsi[1] < 30 ):  
                    self.order = self.buy()
        else:
                if (self.macd[0] < 0 and self.macd[1] > 0 
                  and self.rsi[0] < 70 and self.rsi[1] > 70 ):
                    self.order = self.sell()
    except:
        pass

def onBar(mutable context, msg, indicator){
   //...
    for (istock in msg.keys()){
        if(macd > 0 and prevMacd < 0 and rsi > 30 and prersi < 30 ){
            ... // 变量命名和传递
            lastPrice = msg[istock]["close"]
            Backtest::submitOrder(context["engine"], (istock,context["tradeTime"] 
              , 5, lastPrice, 1000, 1),"buy")
        }
        if(macd < 0 and prevMacd > 0 and rsi < 70 and prersi > 70 ){
            ... // 变量命名和传递
            openOrders = Backtest::getOpenOrders(context["engine"], istock, , "close")
			remainQty = sum(nullFill(getOpenQty(openOrders), 0))
            if(pos-remainQty > 0){
                Backtest::submitOrder(context["engine"], (istock,context["tradeTime"]
                   , 5, lastPrice, 1000, 2), "sell")
            }
        }
    }
}

• Backtrader 在大多数情况下是完全基于 Python 的，相比之下， DolphinDB 的回测框架完全基于 C++ 开发。

• DolphinDB 在数据库内实现，这有效地降低了数据持续传入所产生的时间成本。

• DolphinDB 回测插件引入了响应式状态引擎等增量的指标计算引。

• DolphinDB 引入了 JIT，降低了解释代码的时间开销。

void OnTick(){
    //...
   double rsi1 = iRSI(NULL, 0, 11, PRICE_CLOSE, 1);
   double bandsUpper1 = iBands(NULL, 0, 20, 2, 0, PRICE_CLOSE, MODE_UPPER, 1);
   double bandsLower1 = iBands(NULL, 0, 20, 2, 0, PRICE_CLOSE, MODE_LOWER, 1);
   if(buynum ==  0 && rsi1 > 70&& Close[1] > Open[1] && Ask > bandsUpper1){   
      OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, Ask-slPoint * Point , 0, 
      "Order Buy",  MagicNum, 0, Blue);
   }
   // rsi 小于 30 ， 上升形态（需要增加） ， 当前价格 打穿下轨
   if(sellnum == 0 && rsi1 < 30&& Open[1] > Close[1] && Bid < bandsLower1){
      OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, Bid + slPoint * Point , 0, 
      "Order Sell", MagicNum, 0, Red);  
   }
}

def onBar(mutable context, msg, indicator){ // 主要策略实现函数
	//...
	if(rsi_ > 70. and askPrice0 > bhigh and close > open){
	        if(longpos <1){
				 //... 
	            orderId=Backtest::submitOrder(context["engine"], 
				(istock,symbolSource,
	            context["barTime"], 5, round(askPrice0,5), 
	            askPrice0 - context["sl"] + context['Slippage'],
				askPrice0 + context["tp"] + context['Slippage'], 
	            2, 1, context['Slippage'], 0, 
				context["barTime"]+36000000), "openBuy", 5)
	        	return
    		}
    	}
	if(rsi_ < 30. and bidPrice0 < blow and close < open){
		if(shortpos <1){
			 // ...
		    orderId=Backtest::submitOrder(context["engine"], (istock, symbolSource,
		    context["barTime"], 5, round(bidPrice0,5), 
		    bidPrice0 + context["sl"] - context['Slippage'], 
		    bidPrice0 - context["tp"] - context['Slippage'], 2, 2, 
			context['Slippage'], 0, 
		    context["barTime"] + 36000000), "openSell", 5)
			return
		}
	}
}

• 买入开仓：RSI 值大于 70 且 ATR 大于其 10 分钟均值

• 卖出开仓：RSI 值小于 30 且 ATR 大于其 10 分钟均值

• 卖平：持有多仓时，K 线达到最高点后，回落 0.004 时

• 买平：持有空仓时，K 线达到最低点后，反弹 0.004 时

   def on_bar(self, bar: BarData):
        """
        Callback of new bar data update.
        """
        #...
        atr_array = am.atr(self.atr_length, array=True)
        self.atr_value = atr_array[-1]
        self.atr_ma = atr_array[-self.atr_ma_length:].mean()
        self.rsi_value = am.rsi(self.rsi_length)
        if self.pos == 0:
            self.intra_trade_high = bar.high_price
            self.intra_trade_low = bar.low_price
            if self.atr_value > self.atr_ma:
                if self.rsi_value > self.rsi_buy:
                    self.buy(bar.close_price + 5, self.fixed_size)
                elif self.rsi_value < self.rsi_sell:
                    self.short(bar.close_price - 5, self.fixed_size)
        if (self.pos > 0) &(bar.high_price > self.intra_trade_high):
             self.intra_trade_high = bar.high_price
        elif (self.pos > 0)  & 
          (bar.close_price < self.intra_trade_high*(1 - self.closeLine)):
            self.sell(bar.close_price, abs(self.pos), stop = True)
        if (self.pos < 0) &(bar.low_price < self.intra_trade_low):
             self.intra_trade_low = bar.low_price
        elif (self.pos < 0)  & 
          (bar.close_price > self.intra_trade_low*(1 + self.closeLine)):
            self.cover(bar.close_price, abs(self.pos), stop=True)

        #...

def onBar(mutable context, msg, indicator){
	keys =msg.keys()
	for(i in keys){
		... // 
		//没有多头持仓，并且多头趋势时，买入
		if(longPos < 1 and shortPos < 1 and atr>matr 
			and rsi > context["buySignalRSI"] and matr > 0){
			Backtest::submitOrder(context["engine"], (istock, symbolSource,
			context["tradeTime"], 5, price + 0.02, 0., 2, 1, 0), "buyOpen")
		        	highDict[istock] = price
		        	continue
		}
		//没有空头持仓，并且空头趋势时，卖出
		if(longPos < 1 and shortPos < 1 and atr > matr 
			and rsi < context["sellSignalRSI"] and matr > 0){
			Backtest::submitOrder(context["engine"], ( istock,
				symbolSource,context["tradeTime"], 5, price-0.02, 0., 2, 2, 0), 
				"sellOpen")
		    lowDict[istock] = price
		    continue
		}
		if(longPos > 0 and price > highDict[istock]){//更新最高价
		        	highDict[istock] = max(price, highDict[istock])
		} 
		else if(longPos > 0  
			and price <= highDict[istock]*(1 - context["closeLine"])){
		//平仓
			Backtest::submitOrder(context["engine"], (istock, symbolSource,
				context["tradeTime"], 5, price - 0.02, 0., 2, 3, 0), "sellClose")
		}
		if(shortPos > 0 and price < lowDict[istock]){//更新最低价
		        	lowDict[istock] = min(price, lowDict[istock])
		} 
		else if(shortPos > 0  
			and price >= lowDict[istock]*(1 + context["closeLine"])){
		//平仓
			Backtest::submitOrder(context["engine"], (istock, symbolSource, 
				context["tradeTime"], 5, price + 0.02, 0., 2, 4, 0), "buyClose")
		}		
	}
}

• 买入开仓：当买方的成交量高于卖方成交量的两倍且卖方成交量大于零时，给出买入信号；获取当前持仓数量，如果持仓数量不超出最大值，并以当前的最佳卖价提交买单。

• 卖出开仓：当卖方的成交量高于买方成交量的两倍且买方成交量大于零时，给出卖出信号；获取当前持仓数量，确保有足够的仓位可供卖出，然后以当前最佳买价提交卖出委托订单。

# 快照数据回调
def on_quote(context, quote, location, dest):
    #...
    # 策略逻辑
    ask_volume_sum = sum(x for x in quote.ask_volume)
    bid_volume_sum = sum(x for x in quote.bid_volume)
    if bid_volume_sum > 2 * ask_volume_sum and ask_volume_sum > 0:
        position = get_position(quote.instrument_id, context.book) 
        if not position or position.volume < MAX_POSITION:
            order_id = context.insert_order(quote.instrument_id, 
              quote.exchange_id, source, account, quote.ask_price[0], ORDER_VOLUME,
              PriceType.Limit, Side.Buy, Offset.Open)
    if ask_volume_sum > 2 * bid_volume_sum and bid_volume_sum > 0:
        position = get_position(quote.instrument_id, context.book) 
        if position and position.volume > ORDER_VOLUME:
            order_id = context.insert_order(quote.instrument_id, 
              quote.exchange_id, source, account, quote.bid_price[0], ORDER_VOLUME,
              PriceType.Limit, Side.Sell, Offset.Close)
            

def onSnapshot(mutable context, msg, indicator){
	maxP = context["MAX_POSITION"]
	orderV = context["ORDER_VOLUME"]
	istock = msg.symbol
	ask_volume_sum = sum(msg.offerQty)
	bid_volume_sum = sum(msg.bidQty)
	if (ask_volume_sum > 0){
	    if (bid_volume_sum > 2*ask_volume_sum){
	        posL = Backtest::getPosition(context["engine"],istock).longPosition
	        if(posL < maxP){
	            buyPrice = msg.bidPrice[1]
	            Backtest::submitOrder(context["engine"], 
					(istock,context["tradeTime"], 5, buyPrice, orderV, 1),'oimOBUY')	
	        }
	    }
	}
	if (bid_volume_sum > 0){
	    if (2*bid_volume_sum < ask_volume_sum){
	        posH = Backtest::getPosition(context["engine"],istock).shortPosition[0]
	        if(posH >= orderV){
	            sellPrice = msg.offerPrice[1]
	            Backtest::submitOrder(context["engine"],  
					(istock,context["tradeTime"], 5, sellPrice, orderV, 2),'oimOSELL')      	
	        }
	    }
	} 
}