def __init__(self, feed, instrument):
"""
"""
super(DualThrust, self).__init__(feed)
self.__instrument = instrument
self.__open = feed[instrument].getOpenDataSeries()
self.__high = feed[instrument].getHighDataSeries()
self.__low = feed[instrument].getLowDataSeries()
self.__close = feed[instrument].getCloseDataSeries()
# 策略参数
self.__k1 = 0.5
self.__k2 = 0.5
self.__mday = 1
self.__nday = 1
self.__lots = 5
self.__offset = 0
# 用于存储上下轨数据
self.__buyposition = []
self.__sellposition = []
# sma
self.__sma5 = SMA(self.__close, 5)
self.__sma20 = SMA(self.__close, 55)
# 设置手续费
self.__price = None
self.__datetime = None
self.__cash = self.getBroker().getCash()
self.__broker = self.getBroker()
self.__broker.setCommission(TradePercentage(0.003))
def __init__(self, feed, instrument, context, dictOfDataDf):
super(SMACrossOver, self).__init__(feed)
temp = self.getBroker()
temp.setCommission(TradePercentage(0.0001)) # 单独设置手续费。
if isinstance(instrument, list):
self.__instrument = instrument[0]
elif isinstance(instrument, str):
self.__instrument = instrument
else:
raise Exception('不合法的instrument！')
self.__position = None
self.prices = feed[self.__instrument].getPriceDataSeries()
# 这个策略只有一个品种，所以pop出来必然是那个。pop后这个键值对就不存在，不能取两次
if self.realTrade:
logger.debug('实盘')
self.sma = talib.SMA(self.prices.values, 10)
self.sma1 = talib.SMA(self.prices.values, 20)
else:
logger.debug('回测')
length = len(dictOfDataDf[list(
dictOfDataDf.keys())[0]]) # 拿出第一个df的长度
self.sma = ma.SMA(self.prices, 108, maxLen=length)
self.sma1 = ma.SMA(self.prices, 694, maxLen=length)
self.tech = {
self.__instrument: {
'sma short': self.sma,
'sma long': self.sma1
}
}
def __init__(self, feed, win=10):
super(SVMStrategy, self).__init__(feed)
self.__instrument = instrument
self.__position = None
self.getBroker().setCash(initCapital)
self.getBroker().setCommission(TradePercentage(0.003))
self.getBroker().setAllowNegativeCash(True)
self.getBroker().getFillStrategy().setVolumeLimit(1)
self.getBroker().getFillStrategy().setSlippageModel(
VolumeShareSlippage(priceImpact=0.0))
self.__closeDataSeries = feed[instrument].getCloseDataSeries()
self.df = df
self.closeArr = []
self.portfolios = []
self.buys = []
self.sells = []
self.clf = clf
self.X_norm = X_norm
self.y = y
self.actionDates = actionDates
self.win = win
# print 'week count:', len(y)
self.monthCount = 1
self.dayCount = 0
self.errorCount = 0
self.rightCount = 0
def __init__(self, feed, instrument, long_period, short_period):
super(AS002Strategy, self).__init__(feed, Broker(100000, feed, commission=TradePercentage(0.00075)))
self.__instrument = instrument
self.__long_period = long_period
self.__short_period = short_period
self.__position = None
def __init__(self, feed, instrument, n):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.001))
self.__apDataSeries = feed['orcl'].getApDataSeries()
self.__sma = ma.SMA(self.__apDataSeries, n)
self.__position = None
def __init__(self, feed, instrument, bBandsPeriod):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.0002))
self.__position = None
self.setUseAdjustedValues(False)
self.__bbands = bollinger.BollingerBands(feed[instrument].getCloseDataSeries(), bBandsPeriod, 2)
def __init__(self, feed, instrument, n, m):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.001))
self.__position = None
self.__prices = feed[instrument].getPriceDataSeries()
self.__malength1 = int(n)
self.__malength2 = int(m)
def __init__(self, feed, instrument, smaPeriod):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
self.__position = None
self.getBroker().setCommission(TradePercentage(0.001))
# We'll use adjusted close values instead of regular close values.
#self.setUseAdjustedValues(True)
self.__prices = feed[instrument].getPriceDataSeries()
self.__sma = ma.SMA(self.__prices, smaPeriod)
def __init__(self, feed, instrument, ema1_period, ema2_period, ema3_period):
super(AS001Strategy, self).__init__(feed, Broker(100000, feed, commission=TradePercentage(0.00075)))
self.__instrument = instrument
self.__ema1_period = ema1_period
self.__ema2_period = ema2_period
self.__ema3_period = ema3_period
self.__hlc3 = dataseries.SequenceDataSeries()
self.__position = None
def __init__(self, feed, instrument, n, initialCash=1000000):
strategy.BacktestingStrategy.__init__(self, feed, initialCash)
self.__instrument = instrument
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.001))
self.__position = None
self.__prices = feed[instrument].getPriceDataSeries()
self.__malength = int(n)
self.__ma = ma.SMA(self.__prices, self.__malength)
self.__pos = SequenceDataSeries() # record signal
def __init__(self, feed, instrument, bollingerlength, numStdDev,
closelength, ccMAlength, malength, space):
strategy.BacktestingStrategy.__init__(self, feed)
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.002))
self.__instrument = instrument
self.__bollingerlength = int(bollingerlength)
numStdDev = float(numStdDev) / 10
self.__closelength = int(closelength)
self.__ccMAlength = int(ccMAlength)
self.__malength = int(malength)
self.__longPos = None
self.__shortPos = None
self.__close = feed[instrument].getCloseDataSeries()
self.__open = feed[instrument].getOpenDataSeries()
self.__high = feed[instrument].getHighDataSeries()
self.__low = feed[instrument].getLowDataSeries()
self.__datetime = feed[instrument].getDateTimes()
self.__bollinger = bollinger.BollingerBands(self.__close,
self.__bollingerlength,
int(numStdDev))
self.__UpperBand = self.__bollinger.getUpperBand()
self.__LowerBand = self.__bollinger.getLowerBand()
self.__MA = SequenceDataSeries()
self.__space = int(space)
self.__enter = 0
self.__enterLong1 = 0
self.__enterLong2 = 0
self.__enterShort1 = 0
self.__enterShort2 = 0
self.__exitLong1 = 0
self.__exitLong2 = 0
self.__exitShort1 = 0
self.__exitShort1 = 0
#for test
#########################################################################
self.__p = SequenceDataSeries()
self.__filterCon = SequenceDataSeries()
self.__ccMACon1 = SequenceDataSeries()
self.__ccMACon2 = SequenceDataSeries()
self.__enterCon = SequenceDataSeries()
self.__enterLongCon1 = SequenceDataSeries()
self.__enterLongCon2 = SequenceDataSeries()
self.__enterShortCon1 = SequenceDataSeries()
self.__enterShortCon2 = SequenceDataSeries()
self.__exitLongCon1 = SequenceDataSeries()
self.__exitLongCon2 = SequenceDataSeries()
self.__exitShortCon1 = SequenceDataSeries()
self.__exitShortCon2 = SequenceDataSeries()
def __init__(self, feed, instrument, length, initialCash=1000000):
strategy.BacktestingStrategy.__init__(self, feed, initialCash)
self.__instrument = instrument
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.001))
self.__position = None
self.__prices = feed[instrument].getPriceDataSeries()
self.__malength = int(length)
self.__datetime = feed[instrument].getDateTimes()
self.__open = feed[instrument].getOpenDataSeries()
self.__high = feed[instrument].getHighDataSeries()
self.__low = feed[instrument].getLowDataSeries()
self.__close = feed[instrument].getCloseDataSeries()
def __init__(self, feed, instrument, cash, tradePercentage, data, fastPeriod, slowPeriod):
super(MAStrategy, self).__init__(feed)
self.instrument = instrument
self.invested = False
self.shortMA = talib.SMA(data, fastPeriod)
self.longMA = talib.SMA(data, slowPeriod)
self.day = -1
self.getBroker().getFillStrategy().setVolumeLimit(1)
self.getBroker().setCommission(TradePercentage(tradePercentage))
self.getBroker().setCash(cash)
self.getBroker().setAllowNegativeCash(True)
self.buys = []
self.sells = []
self.portfolios = []
def __init__(self, feed, instrument, mall, mals, masl, mass):
strategy.BacktestingStrategy.__init__(self, feed)
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.001))
self.__instrument = instrument
self.__close = feed[instrument].getCloseDataSeries()
self.__longPos = None
self.__shortPos = None
self.__mall = ma.SMA(self.__close, int(mall))
self.__mals = ma.SMA(self.__close, int(mals))
self.__masl = ma.SMA(self.__close, int(masl))
self.__mass = ma.SMA(self.__close, int(mass))
self.__position = SequenceDataSeries()
def __init__(self, feed, instrument, short_l, mid_l, long_l, up_cum):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.001))
self.__position = None
self.__prices = feed[instrument].getPriceDataSeries()
self.__malength1 = int(short_l)
self.__malength2 = int(mid_l)
self.__malength3 = int(long_l)
self.__circ = int(up_cum)
self.__ma1 = ma.SMA(self.__prices, self.__malength1)
self.__ma2 = ma.SMA(self.__prices, self.__malength2)
self.__ma3 = ma.SMA(self.__prices, self.__malength3)
def __init__(self,
feed,
instrument,
fast,
slow,
signal,
initialCash=1000000):
strategy.BacktestingStrategy.__init__(self, feed, initialCash)
self.__instrument = instrument
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.001))
self.__position = None
self.__prices = feed[instrument].getPriceDataSeries()
self.__fast = int(fast)
self.__slow = int(slow)
self.__signal = int(signal)
def main(plot):
instruments = ['bitmex_XBTUSD','okex_BTCUSDT']
feed = Feed(Frequency.SECOND)
feed.loadBars("bitmex_XBTUSD", test_back=True)
feed.loadBars("okex_BTCUSDT", test_back=True)
'''初始保证金'''
initCash = 1000000
'''手续费设置
目前不支持多标的设置不同的手续费类型
3种手续费类型：
NoCommission：None 默认
FixedPerTrade：固定金额
TradePercentage：按比例收费
'''
commission = TradePercentage(0.0003)
broker = Broker(initCash,feed,commission)
#设置为滑点模型，默认为 NoSlippage
#broker.getFillStrategy().setSlippageModel(VolumeShareSlippage)
#设置交易量限制
#每一个bar中的 volume * limit
#broker.getFillStrategy().setVolumeLimit(0.1)
strat = MultiSymbols(feed, instruments, broker)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
returnsAnalyzer = returns.Returns()
strat.attachAnalyzer(returnsAnalyzer)
if plot:
plt = plotter.StrategyPlotter(strat, False, False, True)
plt.getOrCreateSubplot("cash").addCallback("Cash", lambda x: strat.getBroker().getCash())
# Plot strategy vs. SPY cumulative returns.
# plt.getOrCreateSubplot("returns").addDataSeries("SPY", cumret.CumulativeReturn(feed["SPY"].getPriceDataSeries()))
plt.getOrCreateSubplot("returns").addDataSeries("Strategy", returnsAnalyzer.getCumulativeReturns())
strat.run()
print("Sharpe ratio: %.2f" % sharpeRatioAnalyzer.getSharpeRatio(0.05))
print("Returns: %.2f %%" % (returnsAnalyzer.getCumulativeReturns()[-1] * 100))
if plot:
plt.plot()
def __init__(self, feed, instrument, df, shortWin=20, longWin=40):
super(MyStrategy, self).__init__(feed)
self.__instrument = instrument
self.__position = None
self.getBroker().setCash(100000)
self.getBroker().setCommission(TradePercentage(0.003))
self.getBroker().setAllowNegativeCash(True)
self.getBroker().getFillStrategy().setVolumeLimit(1)
self.getBroker().getFillStrategy().setSlippageModel(
VolumeShareSlippage(priceImpact=0.0))
self.__closeDataSeries = feed[instrument].getCloseDataSeries()
self.df = df
self.shortWin = shortWin
self.longWin = longWin
self.closeArr = []
self.fastSMA = []
self.slowSMA = []
self.buys = []
self.sells = []
self.portfolios = []
def __init__(self, feed, instrument, short_l, mid_l, long_l, up_cum):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.0002))
self.__position = None
self.setUseAdjustedValues(False)
self.__prices = feed[instrument].getPriceDataSeries()
self.__malength1 = int(short_l)
self.__malength2 = int(mid_l)
self.__malength3 = int(long_l)
self.__circ = int(up_cum)
self.__ma1 = ma.SMA(self.__prices, self.__malength1)
self.__ma2 = ma.SMA(self.__prices, self.__malength2)
self.__ma3 = ma.SMA(self.__prices, self.__malength3)
self.__datetime = feed[instrument].getDateTimes()
self.__open = feed[instrument].getOpenDataSeries()
self.__high = feed[instrument].getHighDataSeries()
self.__low = feed[instrument].getLowDataSeries()
self.__close = feed[instrument].getCloseDataSeries()
def __init__(self, feed, instrument,up_cum,cash_or_brk=10000):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.001))
self.__position = None
self.__prices = feed[instrument].getPriceDataSeries()
self.__circ = int(up_cum)
#self.bardata = feed[instrument]
#self.N = atr.ATR(self.bardata, up_cum)
self.N = atr.ATR(self.getFeed()[self.__instrument], up_cum)
self.U = 0 # 总资金100w self.U = acount/(50*atr) 2%最大回撤+10倍杠杆 atr day:100 10min:20 1min:5 5w本金 day :1 10min:5 1min:20 #单个市场上 最多建立4个U
self.buyPrice = []
self.shortPrice = []
self.max20 = 0
self.min10 = 0
self.max10 = 0
self.min20 = 0
self.buyPrice0 = 0
self.shortPrice0 = 0
self.lastPrice0 = 0
self.lastPrice1 =0
def __init__(self, feed, instrument, bBandsPeriod, dl):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.0002))
self.__position = None
self.bBandsPeriod = bBandsPeriod
# self.setUseAdjustedValues(False)
self.close = feed[instrument].getCloseDataSeries()
self.open = feed[instrument].getOpenDataSeries()
self.high = feed[instrument].getHighDataSeries()
self.low = feed[instrument].getLowDataSeries()
self.datetime = feed[instrument].getDateTimes()
self.volume = feed[instrument].getVolumeDataSeries()
self.feed = feed.get_dataFrame()
# self.__bollinger = bollinger.BollingerBands(self.__close, self.bBandsPeriod,2)
# self.__UpperBand = self.__bollinger.getUpperBand()
# self.__LowerBand = self.__bollinger.getLowerBand()
# self.feed = feed[instrument].getCloseDataSeries()
# self.bar = feed[instrument].getClose()
self.dl = dl
self.op = []
# self.ra = []
self.ral = []
self.rah = []
self.boll = []
self.macd = []
self.rsi = []
self.kdj = []
self.rsi = []
self.ma = []
self.adj = []
# self.adjh = []
self.bdj = []
# self.bdjh = []
self.statusl = []
self.statush = []
class subClass(ORB, analyzer.ANALYZER):
def __init__(self, feed, instrument, broker, openrange, p_a, p_c,
isFinancialFuture, debug):
ORB.__init__(self, fd, instrument, broker, openrange, p_a, p_c,
isFinancialFuture, debug)
analyzer.ANALYZER.__init__(self)
# from TestStrategy import MyStrategy
# b=MyStrategy(a,"Y00")
fd = mysqlitefeed(DB_ORIGIN, 60, 5 * 380)
fd.loadBars(symbol, 20150928, 20151009)
commission = TradePercentage(commission_y00)
brkr = broker.backtesting.Broker(10000000, fd, commission)
a = subClass(fd, symbol, brkr, orr, 1, 2, False, False)
a.run()
a.myAppend()
# ds=a.fetchdata("Y00",a.getFrequency(),20150901,20150902,None)
# x=ds[100]
# tmp = x[1].strip().split(':')
# idate=x[0]
# tmp4= int(tmp[0])
# tmp5= int(tmp[1])
# idate1=tri_poly(idate)
# tmp0 = formdatetime_60(x[0], int(str(tmp[0])), int(str(tmp[1])))