Shulou(Shulou.com)06/02 Report--

This article introduces how the grid trading strategy of VNPY single variety futures is realized. The content is very detailed. Interested friends can use it for reference. I hope it will be helpful to you.

The grid trading strategy of single variety futures is realized here. When bar.close is in the channel, the next bar will open multiple orders on the upper track and empty orders on the lower track. The average trading method is used here, that is, the number of orders is the same for each order, not a pyramid. When there are multiple orders, break through online plus multiple orders, break through offline situations to clear all multiple orders, when multiple orders reach the defined maximum number of orders no longer place orders in order to prevent fluctuations up and down one line, resulting in repeated opening and closing, if a breakthrough is made, such as leveling multiple orders, no more orders can be issued for the last n bar, only empty orders can be issued. On the contrary, after the empty order, now this strategy is very rough, only do logical analysis, can be back-tested, consider involving position control, don't make a firm offer.

Click (here) to collapse or open

# encoding: UTF-8

From _ _ future__ import division

From vnpy.trader.vtGateway import *

From math import isnan

Import numpy as np

Import pandas as pd

From vnpy.trader.app.ctaStrategy.ctaTemplate import (CtaTemplate, TargetPosTemplate

BarGenerator

ArrayManager)

Class GridStrategy (CtaTemplate):

ClassName = 'GridStrategy'

Author = upright BillyZhang'

# Policy parameters

HistoryBars = 200 # Historical data size, used to determine the grid baseline

InitDays = 20 # the number of days it takes to initialize the data, which will change with the size of the historical data

Gridlines = 10 # number of gridlines, number of sides

Ordersize = 10 # maximum position

Order = 1 # number of orders per order

Time of barMins = 30 # bar

FrozenBars = 1 # after closing the position, frozenBars bar will no longer issue a reverse order.

AtrWindow = 30 # ATR window

SlMultiplier = 5.0# multiplier for calculating stop distance

# basic variables

Upline = 0 # currently launched

Bottomline = 0 # currently offline

Frozen = 0 # whether to freeze the opening of reverse order currently

IntraTradeHigh = 0

IntraTradeLow = 0

AtrValue = 0

# Parameter list, saving the name of the parameter

ParamList = ['name'

'className'

'author'

'vtSymbol'

'historyBars'

'initDays'

'gridlines'

'barMins'

'order'

'ordersize'

'atrWindow'

'slMultiplier'

]

# list of variables, saving the name of the variable

VarList = ['inited'

'trading'

'pos'

'frozen'

'upline'

'bottomline'

'atrValue']

# synchronization list, saving the names of variables that need to be saved to the database

SyncList = ['pos'

'frozen']

#-

Def _ _ init__ (self, ctaEngine, setting):

"" Constructor "

Super (GridStrategy, self). _ _ init__ (ctaEngine, setting)

Self.bg = BarGenerator (self.onBar, self.barMins, self.onXminBar) # create K-line synthesizer object

Self.am = ArrayManager (self.historyBars + 50)

#-

Def onInit (self):

"" initialization policy (must be inherited by the user) ""

Self.writeCtaLog (Utility% s policy initialization'% self.name)

# load historical data and initialize policy values by playback calculation

InitData = self.loadBar (self.initDays)

For bar in initData:

Self.onBar (bar)

Self.putEvent ()

Def onStart (self):

"" Startup policy (must be inherited and implemented by the user) ""

Self.writeCtaLog (uplink% s policy starts'% self.name)

Self.putEvent ()

Def onStop (self):

"" stop policy (must be inherited and implemented by the user) ""

Self.writeCtaLog (uplink% s policy stops'% self.name)

Self.putEvent ()

#-

Def onXminBar (self, bar):

"" received X-minute K-line ""

# withdraw all previous entrustment

Self.cancelAll ()

# Save K-line data

Am = self.am

Am.updateBar (bar)

If not am.inited:

Return

# the average transaction method is used here, that is, each transaction.

# in short positions, multiple orders are issued for each breakthrough online, and for breakthroughs offline, empty orders are issued

# when there are multiple orders, break through online plus multiple orders, break through offline situations to clear all multiple orders

# when there are empty orders, break through the offline and empty orders, and break through the online to clear all the empty orders

# in order to prevent it from fluctuating up and down a line, resulting in repeated opening and closing, if you break through the closing of positions, such as closing multiple orders, you can only issue empty orders instead of more orders for the last n bar; otherwise, you can open empty orders.

# the last n bar can only be billed more than one.

# calculate the grid, return to the channel queue, and then calculate the channel where the current point is located. 0 is the lowest channel and 2*self.gridlines-1 is the top channel.

Baseline = self.am.sma (self.historyBars)

# the standard deviation of the past 300, making a queue according to the rounding of the top gridlines

Intervallist = baseline+ np.array ([n * 1.00 / self.gridlines for n in range (- 1 * self.gridlines, self.gridlines + 1)]) * self.am.std (self.historyBars)

Griploc = pd.cut ([bar.close], intervallist, labels= [nx for nx in range (0jingself.gridlines)]) [0]

# if nan is returned, it means that bar.close is now outside the range of standard deviation. If there is no position, it will not be processed first. If so, move according to the ATR fluctuation to stop the profit.

If isnan (griploc):

# holding a long position

If self.pos > 0:

Self.intraTradeHigh = max (self.intraTradeHigh, bar.high)

Self.intraTradeLow = bar.low

Self.longStop = self.intraTradeHigh-self.atrValue * self.slMultiplier

Self.sell (self.longStop, abs (self.pos), True)

# holding a short position

Elif self.pos

< 0: self.intraTradeHigh = bar.high self.intraTradeLow = min(self.intraTradeLow, bar.low) self.shortStop = self.intraTradeLow + self.atrValue * self.slMultiplier self.cover(self.shortStop, abs(self.pos), True) return #返回上下线： self.upline = intervallist[griploc + 1] self.bottomline = intervallist[griploc] # 空仓时候，每次突破上线是开多单，突破下线是开空单； # 如果此时在最下一个通道，此时只挂往上的多单, 如果在最上面通道，此时只挂往下空单；如果在中间的，则同时开上下单 if self.pos == 0: if griploc ==0: self.buy(self.upline, self.order, True) elif griploc == 2*self.gridlines - 1: self.short(self.bottomline,self.order,True) else: #此时如果frozen 为0， 直接开上下单： if self.frozen == 0: self.buy(self.upline, self.order, True) self.short(self.bottomline, self.order, True) #此时如果大于0，只能开空单，如果小于0，只能开多单 elif self.frozen >

0:

Self.frozen = self.frozen-1

Self.short (self.bottomline, self.order, True)

Elif self.frozen

< 0: self.frozen = self.frozen + 1 self.buy(self.upline, self.order, True) #如果持有多仓时候，如果在中间通道，同时开上下单；如果最高点位不再开单，突破最大标准差高点， elif self.pos >

0:

# it is impossible to have multiple orders in the lowest channel. Only consider that in the middle section, if the pos is less than ordersize, you can increase the position, otherwise you can only close the position downward; and in the case of the highest section, the highest section is set to close the position downward.

If griploc = = 2*self.gridlines-1:

Self.intraTradeHigh = bar.high

Self.sell (self.bottomline, abs (self.pos), True)

Else:

If abs (self.pos) < self.ordersize:

Self.buy (self.upline, self.order, True)

Self.sell (self.bottomline, abs (self.pos), True)

Else:

Self.sell (self.bottomline, abs (self.pos), True)

Elif self.pos < 0:

# the top channel cannot have an empty order, only the middle section and the lowest level need to be considered

If griploc = = 0:

Self.intraTradeLow = bar.low

Self.cover (self.upline,abs (self.pos), True)

Else:

If abs (self.pos) < self.ordersize:

Self.cover (self.upline, abs (self.pos), True)

Self.sell (self.bottomline, self.order, True)

Else:

Self.cover (self.upline, abs (self.pos), True)

#-

Def onTick (self, tick):

"" receive quotation TICK push (must be inherited by the user) ""

Self.bg.updateTick (tick)

#-

Def onBar (self, bar):

"" receive Bar push (must be inherited by the user) ""

Self.bg.updateBar (bar)

#-

Def onOrder (self, order):

"" received commission push ""

Pass

#-

Def onTrade (self, trade):

# issue a status update event

# if you receive the deal, clear all pending orders

Self.cancelAll ()

# if the trading is in the long direction and the position is now 0, the short position should be closed and the short order should no longer be issued

If trade.direction = = DIRECTION_LONG and self.pos = = 0:

Self.frozen =-1 * self.frozen

# if the short position is in the direction of trading and the position is now 0, then the position should be more than closed and no more orders should be issued.

Elif trade.direction = = DIRECTION_SHORT and self.pos = = 0:

Self.frozen = self.frozen

Self.putEvent ()

#-

Def onStopOrder (self, so):

"" stop single push ""

Pass

On the VNPY single variety futures grid trading strategy is how to share here, I hope that the above content can be of some help to you, can learn more knowledge. If you think the article is good, you can share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.