class SingleMA(strategy.BacktestingStrategy):
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 getPrice(self):
return self.__prices
def getMA(self):
return self.__ma
def testCon(self):
if self.__position is not None:
self.__pos.append(1)
elif self.__position is None:
self.__pos.append(0)
def getPos(self):
return self.__pos
def onEnterCanceled(self, position):
self.__position = None
def onEnterOk(self, position):
execInfo = position.getEntryOrder().getExecutionInfo()
instrumentInfo = position.getInstrument()
self.info("BUY %s at $%.2f" % (instrumentInfo, execInfo.getPrice()))
def onExitOk(self, position):
execInfo = position.getExitOrder().getExecutionInfo()
instrumentInfo = position.getInstrument()
self.info("SELL %s at $%.2f" % (instrumentInfo, execInfo.getPrice()))
self.__position = None
def onExitCancelled(self, position):
self.__position.exitMarket()
def onBars(self, bars):
closePrice = bars[self.__instrument].getPrice()
if self.__ma[-1] is None:
return
self.testCon()
if self.__position is not None:
if not self.__position.exitActive() and closePrice < self.__ma[-1]:
self.__position.exitMarket()
if self.__position is None:
if closePrice > self.__ma[-1]:
shares = int(self.getBroker().getEquity() * 0.9 / closePrice)
self.__position = self.enterLong(self.__instrument, shares)
class fourSMA(strategy.BacktestingStrategy):
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 getPrice(self):
return self.__prices
def getSMA(self):
return self.__mall, self.__mals, self.__mass, self.__masl
def testCon(self):
# record position
#######################################################################
if self.__longPos is not None:
self.__position.append(1)
if self.__shortPos is not None:
self.__position.append(-1)
elif self.__longPos is None and self.__shortPos is None:
self.__position.append(0)
def getTest(self):
return self.__position
def onEnterCanceled(self, position):
if self.__longPos == position:
self.__longPos = None
elif self.__shortPos == position:
self.__shortPos = None
else:
assert (False)
def onExitOk(self, position):
if self.__longPos == position:
self.__longPos = None
elif self.__shortPos == position:
self.__shortPos = None
else:
assert (False)
def onExitCanceled(self, position):
position.exitMarket()
def onEnterOk(self, position):
pass
def onBars(self, bars):
bar = bars[self.__instrument]
if self.__mall[-1] is None:
return
self.testCon()
if self.__longPos is not None:
if self.exitLongSignal():
self.__longPos.exitMarket()
elif self.__shortPos is not None:
if self.exitShortSignal():
self.__shortPos.exitMarket()
elif self.__longPos is None and self.__shortPos is None:
if self.enterLongSignal():
shares = int(self.getBroker().getEquity() * 0.2 /
bar.getPrice())
self.__longPos = self.enterLong(self.__instrument, shares)
elif self.enterShortSignal():
shares = int(self.getBroker().getEquity() * 0.2 /
bar.getPrice())
self.__shortPos = self.enterShort(self.__instrument, shares)
def enterLongSignal(self):
if cross.cross_above(self.__mals, self.__mall) > 0:
return True
def enterShortSignal(self):
if cross.cross_below(self.__mals, self.__mall) > 0:
return True
def exitLongSignal(self):
if cross.cross_below(
self.__mass,
self.__masl) > 0 and not self.__longPos.exitActive():
return True
def exitShortSignal(self):
if cross.cross_above(
self.__mass,
self.__masl) > 0 and not self.__shortPos.exitActive():
return True
class fourSMA(strategy.BacktestingStrategy):
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 getPrice(self):
return self.__prices
def getSMA(self):
return self.__mall,self.__mals,self.__mass,self.__masl
def testCon(self):
# record position
#######################################################################
if self.__longPos is not None:
self.__position.append(1)
if self.__shortPos is not None:
self.__position.append(-1)
elif self.__longPos is None and self.__shortPos is None:
self.__position.append(0)
def getTest(self):
return self.__position
def onEnterCanceled(self, position):
if self.__longPos == position:
self.__longPos = None
elif self.__shortPos == position:
self.__shortPos = None
else:
assert(False)
def onExitOk(self, position):
if self.__longPos == position:
self.__longPos = None
elif self.__shortPos == position:
self.__shortPos = None
else:
assert(False)
def onExitCanceled(self, position):
position.exitMarket()
def onEnterOk(self, position):
pass
def onBars(self, bars):
bar = bars[self.__instrument]
if self.__mall[-1] is None:
return
self.testCon()
if self.__longPos is not None:
if self.exitLongSignal():
self.__longPos.exitMarket()
elif self.__shortPos is not None:
if self.exitShortSignal():
self.__shortPos.exitMarket()
elif self.__longPos is None and self.__shortPos is None:
if self.enterLongSignal():
shares = int(self.getBroker().getEquity() * 0.2 / bar.getPrice())
self.__longPos = self.enterLong(self.__instrument, shares)
elif self.enterShortSignal():
shares = int(self.getBroker().getEquity() * 0.2 / bar.getPrice())
self.__shortPos = self.enterShort(self.__instrument, shares)
def enterLongSignal(self) :
if cross.cross_above(self.__mals, self.__mall) > 0:
return True
def enterShortSignal(self) :
if cross.cross_below(self.__mals, self.__mall) > 0:
return True
def exitLongSignal(self) :
if cross.cross_below(self.__mass, self.__masl) > 0 and not self.__longPos.exitActive():
return True
def exitShortSignal(self):
if cross.cross_above(self.__mass, self.__masl) > 0 and not self.__shortPos.exitActive():
return True
class bollinger_band(strategy.BacktestingStrategy):
def __init__(self, feed, instrument,longline,shortline,bollingerlength, numStdDev):
strategy.BacktestingStrategy.__init__(self, feed)
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.001))
self.__instrument = instrument
self.__bollingerlength = int(bollingerlength)
self.__close = feed[instrument].getMatchDataSeries()
numStdDev = float(numStdDev) / 10
self.__longPos = []
self.__shortPos = []
self.__macd=macd.MACD(self.__close,shortline,longline,10)
self.__bollinger = bollinger.BollingerBands(self.__macd, self.__bollingerlength, int(numStdDev))
self.__UpperBand = self.__bollinger.getUpperBand()
self.__LowerBand = self.__bollinger.getLowerBand()
self.__position = SequenceDataSeries()
self.__circ=5
self.__lastLongPos=None
self.__lastShortPos=None
self.__barNum=0
self.__macdMin=[]
self.__macdMax=[]
def getPrice(self):
return self.__prices
def getMACD(self):
return self.__macd
def getBollingerBands(self):
return self.__bollinger
def testCon(self):
# record position
#######################################################################
if len(self.__longPos) > 0:
self.__position.append(len(self.__longPos))
if len(self.__shortPos)>0 :
#print(self.__shortPos.getShares())
self.__position.append(-len(self.__shortPos))
elif len(self.__longPos)==0 and len(self.__shortPos)==0:
self.__position.append(0)
#print(0)
def getTest(self):
return self.__position
def onBars(self, bars):
bar = bars[self.__instrument]
lower = self.__bollinger.getLowerBand()[-1]
upper = self.__bollinger.getUpperBand()[-1]
self.__barNum=self.__barNum+1
# print(self.getActivePositions())
if self.__macd[-1] is None:
#print (self.__macd[-1])
return
if self.__macd[-1]>self.__macdMax:
self.__macdMax=self.__macd[-1]
if self.__macd[-1]<=self.__macdMin:
self.__macdMin=self.__macd[-1]
if lower is None or upper is None:
return
self.testCon()
if len(self.__longPos)> 0:
if self.exitLongSignal():
for pos in self.__longPos:
pos.exitMarket()
elif len(self.__shortPos)>0:
if self.exitShortSignal():
for pos in self.__shortPos:
pos.exitMarket()
if self.enterLongSignal():
for i in range(self.enterLongSignal()):
shares = int(self.getBroker().getEquity() * 0.2 / bars[self.__instrument].getMatch())
# self.__longPos.
self.__longPos.append(self.enterLong(self.__instrument, shares))
self.__lastLongPos=self.__barNum
#print('long'+str(shares))
elif self.enterShortSignal():
for i in range(self.enterShortSignal()):
shares = int(self.getBroker().getEquity() * 0.2 / bars[self.__instrument].getMatch())
self.__shortPos.append(self.enterShort(self.__instrument, shares))
self.__lastShortPos=self.__barNum
#print('short'+str(shares))
def enterLongSignal (self) :
if self.__lastLongPos is not None:
if self.__barNum-self.__lastLongPos<60:
return 0
if self.__UpperBand[-1-self.__circ] is None:
return 0
m1 = 0
for i in range(self.__circ):
if self.__macd[-i-1] <= self.__LowerBand[-i-2]:
m1 += 1
if m1 >= self.__circ-1 and cross.cross_above(self.__macd,self.__LowerBand)>0:
if self.__macd[-1]>0:
return 0
else:
if self.__macdMin==self.__macd[-1] :
return 2
else:
return 1
else:
return 0
def enterShortSignal(self) :
if self.__lastShortPos is not None:
if self.__barNum-self.__lastShortPos<60:
return 0
if self.__UpperBand[-1-self.__circ] is None:
return 0
m1 = 0
for i in range(self.__circ):
if self.__macd[-i-1] >= self.__UpperBand[-i-2]:
m1 += 1
if m1 >= self.__circ-1 and cross.cross_below(self.__macd,self.__UpperBand)>0:
if self.__macd[-1]<0:
return 0
else:
if self.__macdMax==self.__macd[-1]:
return 2
else:
return 1
else:
return 0
def exitLongSignal(self) :
if self.__UpperBand[-1-self.__circ] is None:
return False
m1 = 0
for i in range(self.__circ):
if self.__macd[-i-1] >= self.__UpperBand[-i-2]:
m1 += 1
if m1 >= self.__circ-1 and cross.cross_below(self.__macd,self.__UpperBand)>0:
return True
elif self.__macd[-1]>=self.__UpperBand[-1] and self.__macdMax==self.__macd[-1]:
return True
elif self.__macd[-1]*1.001>=self.__UpperBand[-1] and self.__macd[-1]>-0.1:
return True
else:
return False
def exitShortSignal(self):
if self.__UpperBand[-1-self.__circ] is None:
return False
m1 = 0
for i in range(self.__circ):
if self.__macd[-i-1] <= self.__LowerBand[-i-2]:
m1 += 1
if m1 >= self.__circ-1 and cross.cross_above(self.__macd,self.__LowerBand)>0:
return True
elif self.__macd[-1]<=self.__LowerBand[-1] and self.__macdMin==self.__macd[-1]:
return True
elif self.__macd[-1]<=self.__LowerBand[-1]*1.001 and self.__macd[-1]<0.11:
return True
else:
return False
def onEnterCanceled(self, position):
if self.__longPos[-1] == position:
del self.__longPos[-1]
self.__lastLongPos==None
elif self.__shortPos[-1] == position:
del self.__shortPos[-1]
self.__lastShortPos==None
else:
assert(False)
def onEnterOK(self,position):
pass
def onExitOk(self, position):
if isinstance(position,LongPosition):
self.__longPos = []
elif isinstance(position,ShortPosition):
self.__shortPos = []
else:
assert(False)
def onExitCanceled(self, position):
position.exitMarket()
class Bollinger_Bandit(strategy.BacktestingStrategy):
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 getHigh(self):
return self.__high
def getLow(self):
return self.__low
def getClose(self):
return self.__close
def getBollinger(self):
return self.__UpperBand, self.__LowerBand
def getMA(self):
return self.__MA
def getDateTime(self):
return self.__datetime
def getPosition(self):
return self.__p
def getTest(self):
return self.__filterCon, self.__ccMACon1, self.__ccMACon2, \
self.__enterCon, self.__enterLongCon1, self.__enterLongCon2, self.__enterShortCon1, \
self.__enterShortCon2, self.__exitLongCon1, self.__exitLongCon2, \
self.__exitShortCon1, self.__exitShortCon2
def onEnterCanceled(self, position):
if self.__longPos == position:
self.__longPos = None
elif self.__shortPos == position:
self.__shortPos = None
else:
assert (False)
def onExitOk(self, position):
if self.__longPos == position:
self.__longPos = None
elif self.__shortPos == position:
self.__shortPos = None
else:
assert (False)
def onBars(self, bars):
# If a position was not opened, check if we should enter a long position.
bar = bars[self.__instrument]
if len(self.__high) > 1:
print self.__close[-1], self.__high[-1], self.__open[
-1], self.__close[-2]
if self.__UpperBand is not None:
print self.__UpperBand[-1]
# filter datetime
###################################################################################
filterCon = len(self.__close) < max(
self.__bollingerlength, self.__malength, self.__closelength)
self.__filterCon.append(filterCon)
if filterCon:
return
# record position
####################################################################################
if self.__longPos is not None and self.__shortPos is None:
self.__p.append(1)
elif self.__longPos is None and self.__shortPos is not None:
self.__p.append(-1)
else:
self.__p.append(0)
# calculate ccMA
####################################################################################
ccMACon1 = self.__longPos is not None or self.__shortPos is not None
ccMACon2 = self.__malength > self.__ccMAlength
if ccMACon1 and ccMACon2:
self.__malength = self.__malength - 1
elif not ccMACon1:
self.__malength = 50
self.__ccMA = np.mean(self.__close[-self.__malength:])
# print self.__malength, self.__ccMA
self.__MA.append(self.__ccMA)
self.__ccMACon1.append(ccMACon1)
self.__ccMACon2.append(ccMACon2)
#open and close condition
######################################################################################
self.__enterLong1 = (cross.cross_above(self.__high, self.__UpperBand) >
0)
self.__enterLong2 = (bar.getClose() >= max(
self.__close[-self.__closelength:]))
self.__enter = ((self.__UpperBand[-1] - self.__LowerBand[-1]) /
bar.getClose() > float(self.__space) / 1000)
# print (self.__UpperBand[-1] - self.__LowerBand[-1]) / bar.getClose()
self.__enterShort1 = cross.cross_below(self.__low,
self.__LowerBand) > 0
self.__enterShort2 = bar.getClose() <= min(
self.__close[-self.__closelength:])
self.__exitLong1 = (bar.getClose() < self.__ccMA)
self.__exitLong2 = (self.__ccMA < self.__UpperBand[-1])
self.__exitShort1 = (bar.getClose() > self.__ccMA)
self.__exitShort2 = (self.__ccMA > self.__LowerBand[-1])
self.__enterCon.append(self.__enter)
self.__enterLongCon1.append(self.__enterLong1)
self.__enterLongCon2.append(self.__enterLong2)
self.__enterShortCon1.append(self.__enterShort1)
self.__enterShortCon2.append(self.__enterShort2)
self.__exitLongCon1.append(self.__exitLong1)
self.__exitLongCon2.append(self.__exitLong2)
self.__exitShortCon1.append(self.__exitShort1)
self.__exitShortCon2.append(self.__exitShort2)
#open and close
#######################################################################################
if self.__longPos is not None:
if self.exitLongSignal():
self.__longPos.exitMarket()
if self.__shortPos is not None:
print 11
self.info("intend long close")
print(self.__UpperBand[-1] -
self.__LowerBand[-1]) / bar.getClose()
elif self.__shortPos is not None:
if self.exitShortSignal():
self.__shortPos.exitMarket()
self.info("intend short close")
print(self.__UpperBand[-1] -
self.__LowerBand[-1]) / bar.getClose()
else:
if self.enterLongSignal():
shares = int(self.getBroker().getCash() * 0.2 /
bars[self.__instrument].getPrice())
self.__longPos = self.enterLong(self.__instrument, shares)
self.info("intend long open")
print(self.__UpperBand[-1] -
self.__LowerBand[-1]) / bar.getClose()
elif self.enterShortSignal():
shares = int(self.getBroker().getCash() * 0.2 /
bars[self.__instrument].getPrice())
self.__shortPos = self.enterShort(self.__instrument, shares)
self.info("intend short open")
print(self.__UpperBand[-1] -
self.__LowerBand[-1]) / bar.getClose()
def enterLongSignal(self):
if self.__enterLong1 and self.__enterLong2 and self.__enter:
return True
def enterShortSignal(self):
if self.__enterShort1 and self.__enterShort2 and self.__enter:
return True
def exitLongSignal(self):
if self.__exitLong1 and self.__exitLong2 and not self.__longPos.exitActive(
):
return True
def exitShortSignal(self):
if self.__exitShort1 and self.__exitShort2 and not self.__shortPos.exitActive(
):
return True
class thrSMA(strategy.BacktestingStrategy):
def __init__(self, feed, instrument, fast, slow, signal, up_cum):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.0008))
self.__longPos = None
self.__shortPos = None
self.__prices = feed[instrument].getPriceDataSeries()
self.__macd=macd.MACD(self.__prices,fast,slow,signal)
self.__range=0
self.__circ = int(up_cum)
self.__position = SequenceDataSeries()
def getPrice(self):
return self.__prices
def getMACD(self):
return self.__macd
def testCon(self):
# record position
#######################################################################
if self.__longPos is not None:
self.__position.append(1)
if self.__shortPos is not None:
self.__position.append(-1)
elif self.__longPos is None and self.__shortPos is None:
self.__position.append(0)
def getTest(self):
return self.__position
def onEnterCanceled(self, position):
if self.__longPos == position:
self.__longPos = None
elif self.__shortPos == position:
self.__shortPos = None
else:
assert(False)
def onEnterOK(self):
pass
def onExitOk(self, position):
if self.__longPos == position:
self.__longPos = None
elif self.__shortPos == position:
self.__shortPos = None
else:
assert(False)
def onExitCanceled(self, position):
position.exitMarket()
def buyCon1(self):
if self.__macd[-1] < -self.__range:
#print(self.__macd[-1])
return True
else:
return False
def buyCon2(self):
if self.__macd[-1-self.__circ] is None:
return False
m1 = 0
for i in range(self.__circ):
if self.__macd[-i-1] > self.__macd[-i-2]:
m1 += 1
if m1 >= self.__circ:
return True
else:
return False
def exitLongCon1(self):
if self.__macd[-1]>0:
return True
else:
return False
def exitLongCon2(self):
if self.__macd[-1-self.__circ] is None:
return False
m1 = 0
for i in range(self.__circ):
if self.__macd[-i-1] < self.__macd[-i-2]:
m1 += 1
if m1 >= self.__circ:
return True
else:
return False
def exitShortCon1(self):
if self.__macd[-1]<0:
return True
else:
return False
def exitShortCon2(self):
if self.__macd[-1-self.__circ] is None:
return False
m1 = 0
for i in range(self.__circ):
if self.__macd[-i-1] > self.__macd[-i-2]:
m1 += 1
if m1 >= self.__circ:
return True
else:
return False
def sellCon1(self):
if self.__macd[-1] >self.__range:
return True
else:
return False
def sellCon2(self):
if self.__macd[-1-self.__circ] is None:
return False
m1 = 0
for i in range(self.__circ):
if self.__macd[-i-1] < self.__macd[-i-2]:
m1 += 1
if m1 >= self.__circ:
return True
else:
return False
def onBars(self, bars):
# If a position was not opened, check if we should enter a long position.
if self.__macd[-1]is None:
return
self.__range=self.__prices[0]*0.004
self.testCon()
if self.__longPos is not None:
if self.exitLongSignal():
self.__longPos.exitMarket()
elif self.__shortPos is not None:
if self.exitShortSignal():
self.__shortPos.exitMarket()
elif self.__longPos is None and self.__shortPos is None:
if self.enterLongSignal():
shares = int(self.getBroker().getEquity() * 0.2 / bars[self.__instrument].getPrice())
self.__longPos = self.enterLong(self.__instrument, shares)
elif self.enterShortSignal():
shares = int(self.getBroker().getEquity() * 0.2 / bars[self.__instrument].getPrice())
self.__shortPos = self.enterShort(self.__instrument, shares)
def enterLongSignal(self) :
if self.buyCon1() and self.buyCon2():
return True
else:
return False
def enterShortSignal(self) :
if self.sellCon1() and self.sellCon2():
return True
else:
return False
def exitLongSignal(self) :
if self.exitLongCon1() and self.exitLongCon2() and not self.__longPos.exitActive():
return True
else:
return False
def exitShortSignal(self):
if self.exitShortCon1() and self.exitShortCon2() and not self.__shortPos.exitActive():
return True
else:
return False
class Bollinger_Bandit(strategy.BacktestingStrategy):
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.__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 getHigh(self):
return self.__high
def getLow(self):
return self.__low
def getClose(self):
return self.__close
def getBollinger(self):
return self.__UpperBand, self.__LowerBand
def getMA(self):
return self.__MA
def getDateTime(self):
return self.__datetime
def getPosition(self):
return self.__p
def getTest(self):
return self.__filterCon, self.__ccMACon1, self.__ccMACon2, \
self.__enterCon, self.__enterLongCon1, self.__enterLongCon2, self.__enterShortCon1, \
self.__enterShortCon2, self.__exitLongCon1, self.__exitLongCon2, \
self.__exitShortCon1, self.__exitShortCon2
def onEnterCanceled(self, position):
if self.__longPos == position:
self.__longPos = None
elif self.__shortPos == position:
self.__shortPos = None
else:
assert(False)
def onExitOk(self, position):
if self.__longPos == position:
self.__longPos = None
elif self.__shortPos == position:
self.__shortPos = None
else:
assert(False)
def onBars(self, bars):
# If a position was not opened, check if we should enter a long position.
bar = bars[self.__instrument]
# filter datetime
###################################################################################
filterCon = len(self.__close) < max(self.__bollingerlength, self.__malength, self.__closelength)
self.__filterCon.append(filterCon)
if filterCon:
return
# record position
####################################################################################
if self.__longPos is not None and self.__shortPos is None:
self.__p.append(1)
elif self.__longPos is None and self.__shortPos is not None:
self.__p.append(-1)
else:
self.__p.append(0)
# calculate ccMA
####################################################################################
ccMACon1 = self.__longPos is not None or self.__shortPos is not None
ccMACon2 = self.__malength > self.__ccMAlength
if ccMACon1 and ccMACon2:
self.__malength = self.__malength - 1
elif not ccMACon1:
self.__malength = 50
self.__ccMA = np.mean(self.__close[-self.__malength:])
# print self.__malength, self.__ccMA
self.__MA.append(self.__ccMA)
self.__ccMACon1.append(ccMACon1)
self.__ccMACon2.append(ccMACon2)
#open and close condition
######################################################################################
self.__enterLong1 = (cross.cross_above(self.__high, self.__UpperBand) > 0)
self.__enterLong2 = (bar.getClose() >= max(self.__close[-self.__closelength:]))
self.__enter = ((self.__UpperBand[-1] - self.__LowerBand[-1]) / bar.getClose() > float(self.__space) / 1000)
# print (self.__UpperBand[-1] - self.__LowerBand[-1]) / bar.getClose()
self.__enterShort1 = cross.cross_below(self.__low, self.__LowerBand) > 0
self.__enterShort2 = bar.getClose() <= min(self.__close[-self.__closelength:])
self.__exitLong1 = (bar.getClose() < self.__ccMA)
self.__exitLong2 = (self.__ccMA < self.__UpperBand[-1])
self.__exitShort1 = (bar.getClose() > self.__ccMA)
self.__exitShort2 = (self.__ccMA > self.__LowerBand[-1])
self.__enterCon.append(self.__enter)
self.__enterLongCon1.append(self.__enterLong1)
self.__enterLongCon2.append(self.__enterLong2)
self.__enterShortCon1.append(self.__enterShort1)
self.__enterShortCon2.append(self.__enterShort2)
self.__exitLongCon1.append(self.__exitLong1)
self.__exitLongCon2.append(self.__exitLong2)
self.__exitShortCon1.append(self.__exitShort1)
self.__exitShortCon2.append(self.__exitShort2)
#open and close
#######################################################################################
if self.__longPos is not None:
if self.exitLongSignal():
self.__longPos.exitMarket()
# if self.__shortPos is not None:
# print 11
# self.info("intend long close")
# print (self.__UpperBand[-1] - self.__LowerBand[-1]) / bar.getClose()
elif self.__shortPos is not None:
if self.exitShortSignal():
self.__shortPos.exitMarket()
# self.info("intend short close")
# print (self.__UpperBand[-1] - self.__LowerBand[-1]) / bar.getClose()
else:
if self.enterLongSignal():
shares = int(self.getBroker().getCash() * 0.2 / bars[self.__instrument].getPrice())
self.__longPos = self.enterLong(self.__instrument, shares)
# self.info("intend long open")
# print (self.__UpperBand[-1] - self.__LowerBand[-1]) / bar.getClose()
elif self.enterShortSignal():
shares = int(self.getBroker().getCash() * 0.2 / bars[self.__instrument].getPrice())
self.__shortPos = self.enterShort(self.__instrument, shares)
# self.info("intend short open")
# print (self.__UpperBand[-1] - self.__LowerBand[-1]) / bar.getClose()
def enterLongSignal(self):
if self.__enterLong1 and self.__enterLong2 and self.__enter:
return True
def enterShortSignal(self):
if self.__enterShort1 and self.__enterShort2 and self.__enter:
return True
def exitLongSignal(self):
if self.__exitLong1 and self.__exitLong2 and not self.__longPos.exitActive():
return True
def exitShortSignal(self):
if self.__exitShort1 and self.__exitShort2 and not self.__shortPos.exitActive():
return True
class bollinger_band(strategy.BacktestingStrategy):
def __init__(self, feed, instrument, bollingerlength, numStdDev):
strategy.BacktestingStrategy.__init__(self, feed)
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0))
self.__instrument = instrument
self.__bollingerlength = int(bollingerlength)
self.__close = feed[instrument].getPriceDataSeries()
numStdDev = float(numStdDev) / 10
self.__longPos = []
self.__macd=macd.MACD(self.__close,50,150,10)
self.__bollinger = bollinger.BollingerBands(self.__macd, self.__bollingerlength, int(numStdDev))
self.__UpperBand = self.__bollinger.getUpperBand()
self.__LowerBand = self.__bollinger.getLowerBand()
self.__position = SequenceDataSeries()
self.__circ=5
def getPrice(self):
return self.__prices
def getMACD(self):
return self.__macd
def getBollingerBands(self):
return self.__bollinger
def testCon(self):
# record position
#######################################################################
if len(self.__longPos) > 0:
self.__position.append(len(self.__longPos))
elif len(self.__longPos)==0 :
self.__position.append(0)
#print(0)
def getTest(self):
return self.__position
def onBars(self, bars):
bar = bars[self.__instrument]
lower = self.__bollinger.getLowerBand()[-1]
upper = self.__bollinger.getUpperBand()[-1]
# print(self.getActivePositions())
if lower is None:
return
self.testCon()
if len(self.__longPos)> 0:
if self.exitLongSignal():
for pos in self.__longPos:
pos.exitMarket()
elif len(self.__longPos)<5 :
if self.enterLongSignal():
shares =1
# self.__longPos.
self.__longPos.append(self.enterLong(self.__instrument, shares))
def enterLongSignal (self) :
if self.__UpperBand[-1-self.__circ] is None:
return False
m1 = 0
for i in range(self.__circ):
if self.__macd[-i-1] <= self.__LowerBand[-i-2]:
m1 += 1
if m1 >= self.__circ-1 and cross.cross_above(self.__macd,self.__LowerBand)>0:
return True
else:
return False
def enterShortSignal(self) :
if self.__UpperBand[-1-self.__circ] is None:
return False
m1 = 0
for i in range(self.__circ):
if self.__macd[-i-1] >= self.__UpperBand[-i-2]:
m1 += 1
if m1 >= self.__circ-1 and cross.cross_below(self.__macd,self.__UpperBand)>0:
return True
else:
return False
def exitLongSignal(self) :
if self.__UpperBand[-1-self.__circ] is None:
return False
m1 = 0
for i in range(self.__circ):
if self.__macd[-i-1] >= self.__UpperBand[-i-2]:
m1 += 1
if m1 >= self.__circ-1 and cross.cross_below(self.__macd,self.__UpperBand)>0:
return True
else:
return False
def exitShortSignal(self):
if self.__UpperBand[-1-self.__circ] is None:
return False
m1 = 0
for i in range(self.__circ):
if self.__macd[-i-1] <= self.__LowerBand[-i-2]:
m1 += 1
if m1 >= self.__circ-1 and cross.cross_above(self.__macd,self.__LowerBand)>0:
return True
else:
return False
def onEnterCanceled(self, position):
if len(self.__longPos)>0:
if self.__longPos[-1] == position:
del self.__longPos[-1]
#else:
#assert(False)
def onEnterOK(self,position):
pass
def onExitOk(self, position):
if isinstance(position,LongPosition):
self.__longPos = []
else:
assert(False)
def onExitCanceled(self, position):
position.exitMarket()
class rbreaker(strategy.BacktestingStrategy):
def __init__(self, feed, instrument,preclose,prehigh,prelow,p1,p2,p3,p4):
strategy.BacktestingStrategy.__init__(self, feed)
self.getBroker().setFillStrategy(DefaultStrategy(None))
self.getBroker().setCommission(TradePercentage(0.001))
self.__instrument = instrument
self.__longPos = []
self.__shortPos = []
self.__position = SequenceDataSeries()
self.__prices= feed[instrument].getPriceDataSeries()
self.__circ=5
self.__lastLongPos=None
self.__lastShortPos=None
self.__barNum=0
self.__ssetup=prehigh-p1*(preclose-prelow)
self.__senter=((1+p2)/2)*(prehigh+preclose)-p2*prelow
self.__benter=((1+p2)/2)*(prelow+preclose)-p2*prehigh
self.__bsetup=prelow+p1*(prehigh-preclose)
self.__bbreak=self.__ssetup+p3*(self.__ssetup-self.__bsetup)
self.__sbreak=self.__bsetup-p3*(self.__ssetup-self.__bsetup)
self.__moreSsetup=False
self.__lessBsetup=False
self.__couldsbreak=True
self.__couldbbreak=True
self.__p4=p4
def testCon(self):
# record position
#######################################################################
if len(self.__longPos) > 0:
self.__position.append(len(self.__longPos))
if len(self.__shortPos)>0 :
#print(self.__shortPos.getShares())
self.__position.append(-len(self.__shortPos))
elif len(self.__longPos)==0 and len(self.__shortPos)==0:
self.__position.append(0)
#print(0)
def getPrice(self):
return self.__prices
def getTest(self):
return self.__position
def onBars(self, bars):
bar = bars[self.__instrument]
if self.__prices[-1]>self.__ssetup:
self.__moreSsetup=True
else:
self.__couldbbreak=True
if self.__prices[-1]<self.__bsetup:
self.__lessBsetup=True
else:
self.__couldsbreak=True
dt=bars.getDateTime()
h=dt.hour
m=dt.minute
if(h==14 and m>50):
if len(self.__longPos)> 0:
for item in self.__longPos:
if item[0]._Position__exitOrder is None:
item[0].exitMarket()
if len(self.__shortPos)>0:
for item in self.__shortPos:
if item[0]._Position__exitOrder is None:
item[0].exitMarket()
return
self.testCon()
if len(self.__longPos)> 0:
if self.exitLongSignal():
for item in self.__longPos:
if item[0]._Position__exitOrder is None:
item[0].exitMarket()
elif len(self.__shortPos)>0:
if self.exitShortSignal():
for item in self.__shortPos:
if item[0]._Position__exitOrder is None:
item[0].exitMarket()
if self.enterLongSignal():
for i in range(self.enterLongSignal()):
shares = int(self.getBroker().getEquity() * 0.2 / bars[self.__instrument].getPrice())
# self.__longPos.
pos=self.enterLong(self.__instrument, shares)
#pos.exitLimit(bars[self.__instrument].getPrice()*0.99)
self.__longPos.append([pos,0])
self.__lastLongPos=self.__barNum
#print('long'+str(shares))
if self.enterShortSignal():
for i in range(self.enterShortSignal()):
shares = int(self.getBroker().getEquity() * 0.2 / bars[self.__instrument].getPrice())
pos=self.enterShort(self.__instrument, shares)
#pos.exitLimit(bars[self.__instrument].getPrice()*1.01)
self.__shortPos.append([pos,0])
self.__lastShortPos=self.__barNum
def enterLongSignal (self) :
if len(self.__longPos)>=2:
if self.__lessBsetup:
if self.__prices[-1]<self.__benter:
return 1
if self.__couldbbreak:
if self.__prices[-1]>self.__bbreak:
return 1
def enterShortSignal(self) :
if len(self.__shortPos)<=2:
if self.__moreSsetup:
if self.__prices[-1]<self.__senter:
return 1
if self.__couldsbreak:
if self.__prices[-1]<self.__sbreak:
return 1
def exitLongSignal(self) :
for item in self.__longPos:
print(item[1])
if item[0].getReturn()>item[1]:
item[1]=item[0].getReturn()
if item[1]-item[0].getReturn()>self.__p4:
self.__couldbbreak=False
return 1
def exitShortSignal(self):
for item in self.__shortPos:
if item[0].getReturn()>item[1]:
item[1]=item[0].getReturn()
if item[1]-item[0].getReturn()>self.__p4:
self.__couldsbreak=False
return 1
def onEnterCanceled(self, position):
if len(self.__longPos)>0:
if self.__longPos[-1] == position:
del self.__longPos[-1]
self.__lastLongPos==None
if len(self.__shortPos)>0:
if self.__shortPos[-1] == position:
del self.__shortPos[-1]
self.__lastShortPos==None
def onEnterOK(self,position):
pass
def onExitOk(self, position):
if isinstance(position,LongPosition):
self.__longPos = []
elif isinstance(position,ShortPosition):
self.__shortPos = []
else:
assert(False)
def onExitCanceled(self, position):
position.exitMarket()
def getParams(self):
return (self.__bbreak,self.__ssetup,self.__senter,self.__benter,self.__bsetup,self.__sbreak)
class SingleMA(strategy.BacktestingStrategy):
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 getPrice(self):
return self.__prices
def getMA(self):
return self.__ma
def testCon(self):
if self.__position is not None:
self.__pos.append(1)
elif self.__position is None:
self.__pos.append(0)
def getPos(self):
return self.__pos
def onEnterCanceled(self, position):
self.__position = None
def onEnterOk(self, position):
execInfo = position.getEntryOrder().getExecutionInfo()
instrumentInfo = position.getInstrument()
self.info("BUY %s at $%.2f" % (instrumentInfo, execInfo.getPrice()))
def onExitOk(self, position):
execInfo = position.getExitOrder().getExecutionInfo()
instrumentInfo = position.getInstrument()
self.info("SELL %s at $%.2f" % (instrumentInfo, execInfo.getPrice()))
self.__position = None
def onExitCancelled(self, position):
self.__position.exitMarket()
def onBars(self, bars):
closePrice = bars[self.__instrument].getPrice()
if self.__ma[-1] is None:
return
self.testCon()
if self.__position is not None:
if not self.__position.exitActive() and closePrice < self.__ma[-1]:
self.__position.exitMarket()
if self.__position is None:
if closePrice > self.__ma[-1]:
shares = int(self.getBroker().getEquity() * 0.9 / closePrice)
self.__position = self.enterLong(self.__instrument, shares)
