• 算法示例
    • 时间加权平均算法
    • 冰山算法
    • 狙击手算法
    • 条件委托算法
    • 最优限价算法

    算法示例

    时间加权平均算法

    • 将委托数量平均分布在某个时间区域内；
    • 每隔一段时间用指定的价格挂出买单（或者卖单）。
    • 买入情况：买一价低于目标价格时，发出委托，委托数量在剩余委托量与委托分割量中取最小值。
    • 卖出情况：卖一价高于目标价格时，发出委托，委托数量在剩余委托量与委托分割量中取最小值。
    1.     def on_timer(self):
    2.         """"""
    3.         self.timer_count += 1
    4.         self.total_count += 1
    5.         self.put_variables_event()
    6.  
    7.         if self.total_count >= self.time:
    8.             self.write_log("执行时间已结束，停止算法")
    9.             self.stop()
    10.             return
    11.  
    12.         if self.timer_count < self.interval:
    13.             return
    14.         self.timer_count = 0
    15.  
    16.         tick = self.get_tick(self.vt_symbol)
    17.         if not tick:
    18.             return
    19.  
    20.         self.cancel_all()
    21.  
    22.         left_volume = self.volume - self.traded
    23.         order_volume = min(self.order_volume, left_volume)
    24.  
    25.         if self.direction == Direction.LONG:
    26.             if tick.ask_price_1 <= self.price:
    27.                 self.buy(self.vt_symbol, self.price,
    28.                          order_volume, offset=self.offset)
    29.         else:
    30.             if tick.bid_price_1 >= self.price:
    31.                 self.sell(self.vt_symbol, self.price,
    32.                           order_volume, offset=self.offset)

    冰山算法

    • 在某个价位挂单，但是只挂一部分，直到全部成交。
    • 买入情况：先检查撤单：最新Tick卖一价低于目标价格，执行撤单；若无活动委托，发出委托：委托数量在剩余委托量与挂出委托量中取最小值。
    • 卖出情况：先检查撤单：最新Tick买一价高于目标价格，执行撤单；若无活动委托，发出委托：委托数量在剩余委托量与挂出委托量中取最小值。
    1.     def on_timer(self):
    2.         """"""
    3.         self.timer_count += 1
    4.  
    5.         if self.timer_count < self.interval:
    6.             self.put_variables_event()
    7.             return
    8.  
    9.         self.timer_count = 0
    10.  
    11.         contract = self.get_contract(self.vt_symbol)
    12.         if not contract:
    13.             return
    14.  
    15.         # If order already finished, just send new order
    16.         if not self.vt_orderid:
    17.             order_volume = self.volume - self.traded
    18.             order_volume = min(order_volume, self.display_volume)
    19.  
    20.             if self.direction == Direction.LONG:
    21.                 self.vt_orderid = self.buy(
    22.                     self.vt_symbol,
    23.                     self.price,
    24.                     order_volume,
    25.                     offset=self.offset
    26.                 )
    27.             else:
    28.                 self.vt_orderid = self.sell(
    29.                     self.vt_symbol,
    30.                     self.price,
    31.                     order_volume,
    32.                     offset=self.offset
    33.                 )
    34.         # Otherwise check for cancel
    35.         else:
    36.             if self.direction == Direction.LONG:
    37.                 if self.last_tick.ask_price_1 <= self.price:
    38.                     self.cancel_order(self.vt_orderid)
    39.                     self.vt_orderid = ""
    40.                     self.write_log(u"最新Tick卖一价，低于买入委托价格，之前委托可能丢失，强制撤单")
    41.             else:
    42.                 if self.last_tick.bid_price_1 >= self.price:
    43.                     self.cancel_order(self.vt_orderid)
    44.                     self.vt_orderid = ""
    45.                     self.write_log(u"最新Tick买一价，高于卖出委托价格，之前委托可能丢失，强制撤单")
    46.  
    47.         self.put_variables_event()

    狙击手算法

    • 监控最新tick推送的行情，发现好的价格立刻报价成交。
    • 买入情况：最新Tick卖一价低于目标价格时，发出委托，委托数量在剩余委托量与卖一量中取最小值。
    • 卖出情况：最新Tick买一价高于目标价格时，发出委托，委托数量在剩余委托量与买一量中取最小值。
    1.     def on_tick(self, tick: TickData):
    2.         """"""
    3.         if self.vt_orderid:
    4.             self.cancel_all()
    5.             return
    6.  
    7.         if self.direction == Direction.LONG:
    8.             if tick.ask_price_1 <= self.price:
    9.                 order_volume = self.volume - self.traded
    10.                 order_volume = min(order_volume, tick.ask_volume_1)
    11.  
    12.                 self.vt_orderid = self.buy(
    13.                     self.vt_symbol,
    14.                     self.price,
    15.                     order_volume,
    16.                     offset=self.offset
    17.                 )
    18.         else:
    19.             if tick.bid_price_1 >= self.price:
    20.                 order_volume = self.volume - self.traded
    21.                 order_volume = min(order_volume, tick.bid_volume_1)
    22.  
    23.                 self.vt_orderid = self.sell(
    24.                     self.vt_symbol,
    25.                     self.price,
    26.                     order_volume,
    27.                     offset=self.offset
    28.                 )
    29.  
    30.         self.put_variables_event()

    条件委托算法

    • 监控最新tick推送的行情，发现行情突破立刻报价成交。
    • 买入情况：Tick最新价高于目标价格时，发出委托，委托价为目标价格加上超价。
    • 卖出情况：Tick最新价低于目标价格时，发出委托，委托价为目标价格减去超价。
    1.     def on_tick(self, tick: TickData):
    2.         """"""
    3.         if self.vt_orderid:
    4.             return
    5.  
    6.         if self.direction == Direction.LONG:
    7.             if tick.last_price >= self.stop_price:
    8.                 price = self.stop_price + self.price_add
    9.  
    10.                 if tick.limit_up:
    11.                     price = min(price, tick.limit_up)
    12.  
    13.                 self.vt_orderid = self.buy(
    14.                     self.vt_symbol,
    15.                     price,
    16.                     self.volume,
    17.                     offset=self.offset
    18.                 )
    19.                 self.write_log(f"停止单已触发，代码：{self.vt_symbol}，方向：{self.direction}, 价格：{self.stop_price}，数量：{self.volume}，开平：{self.offset}")                   
    20.  
    21.         else:
    22.             if tick.last_price <= self.stop_price:
    23.                 price = self.stop_price - self.price_add
    24.  
    25.                 if tick.limit_down:
    26.                     price = max(price, tick.limit_down)
    27.  
    28.                 self.vt_orderid = self.buy(
    29.                     self.vt_symbol,
    30.                     price,
    31.                     self.volume,
    32.                     offset=self.offset
    33.                 )
    34.                 self.write_log(f"停止单已触发，代码：{self.vt_symbol}，方向：{self.direction}, 价格：{self.stop_price}，数量：{self.volume}，开平：{self.offset}") 
    35.  
    36.         self.put_variables_event()

    最优限价算法

    • 监控最新tick推送的行情，发现好的价格立刻报价成交。
    • 买入情况：先检查撤单：最新Tick买一价不等于目标价格时，执行撤单；若无活动委托，发出委托：委托价格为最新Tick买一价，委托数量为剩余委托量。
    • 卖出情况：先检查撤单：最新Tick买一价不等于目标价格时，执行撤单；若无活动委托，发出委托：委托价格为最新Tick卖一价，委托数量为剩余委托量。
    1.     def on_tick(self, tick: TickData):
    2.         """"""
    3.         self.last_tick = tick
    4.  
    5.         if self.direction == Direction.LONG:
    6.             if not self.vt_orderid:
    7.                 self.buy_best_limit()
    8.             elif self.order_price != self.last_tick.bid_price_1:
    9.                 self.cancel_all()
    10.         else:
    11.             if not self.vt_orderid:
    12.                 self.sell_best_limit()
    13.             elif self.order_price != self.last_tick.ask_price_1:
    14.                 self.cancel_all()
    15.  
    16.         self.put_variables_event()
    17.  
    18.     def buy_best_limit(self):
    19.         """"""
    20.         order_volume = self.volume - self.traded
    21.         self.order_price = self.last_tick.bid_price_1
    22.         self.vt_orderid = self.buy(
    23.             self.vt_symbol,
    24.             self.order_price,
    25.             order_volume,
    26.             offset=self.offset
    27.         )        
    28.  
    29.     def sell_best_limit(self):
    30.         """"""
    31.         order_volume = self.volume - self.traded
    32.         self.order_price = self.last_tick.ask_price_1
    33.         self.vt_orderid = self.sell(
    34.             self.vt_symbol,
    35.             self.order_price,
    36.             order_volume,
    37.             offset=self.offset
    38.         )