def __init__(self, feed, entrySMA, exitSMA, rsiPeriod, overBoughtThreshold,
overSoldThreshold):
strategy.BacktestingStrategy.__init__(self, feed, 2000)
ds = feed["dia"].getCloseDataSeries()
self.__entrySMA = ma.SMA(ds, entrySMA)
self.__exitSMA = ma.SMA(ds, exitSMA)
self.__rsi = rsi.RSI(ds, rsiPeriod)
self.__overBoughtThreshold = overBoughtThreshold
self.__overSoldThreshold = overSoldThreshold
self.__longPos = None
self.__shortPos = None
def __init__(self, feed, instrument, n, m):
strategy.BacktestingStrategy.__init__(self, feed, 1000)
self.__position = None
self.__instrument = instrument
self.__prices = feed[instrument].getPriceDataSeries()
self.__malength1 = int(n)
self.__malength2 = int(m)
self.__ma1 = ma.SMA(self.__prices, self.__malength1)
self.__ma2 = ma.SMA(self.__prices, self.__malength2)
def initIndicators(self):
#mid 3)
self.__sma = {}
self.__lma = {}
for instrument in self.instruments:
self.__sma[instrument] = ma.SMA(self.closePrices[instrument],
self.__shortPeriod,
maxLen=self.mid_DEFAULT_MAX_LEN)
self.__lma[instrument] = ma.SMA(self.closePrices[instrument],
self.__longPeriod,
maxLen=self.mid_DEFAULT_MAX_LEN)
def __init__(self, feed, smaPeriod): strategy.Strategy.__init__(self, feed) assert(smaPeriod > 3) self.__lead = "nikkei" self.__lag = "spy" # Exit signal is more sensitive than entry. adjClose = feed.getDataSeries(self.__lead).getAdjCloseDataSeries() self.__crossAbove = cross.CrossAbove(adjClose, ma.SMA(adjClose, smaPeriod)) self.__crossBelow = cross.CrossAbove(adjClose, ma.SMA(adjClose, int(smaPeriod/2))) self.__pos = None
def __init__(self, feed, instrument, brk):
super(MyStrategy, self).__init__(feed, brk)
self.__position = None
self.__instrument = instrument
# We'll use adjusted close values instead of regular close values.
self.setUseAdjustedValues(True)
self.__prices = feed[instrument].getPriceDataSeries()
self.__sma = {}
self.__sma[60] = ma.SMA(self.__prices, 60)
self.__sma[10] = ma.SMA(self.__prices, 10)
self.__sma[30] = ma.SMA(self.__prices, 30)
def __init__(self, feed, smaPeriod):
strategy.BacktestingStrategy.__init__(self, feed)
assert (smaPeriod > 3)
self.__lead = "^n225"
self.__lag = "spy"
self.__adjClose = feed[self.__lead].getAdjCloseDataSeries()
# Exit signal is more sensitive than entry.
self.__fastSMA = ma.SMA(self.__adjClose, int(smaPeriod / 2))
self.__slowSMA = ma.SMA(self.__adjClose, smaPeriod)
self.__pos = None
def __init__(self, feed, instrument):
super(MyStrategy, self).__init__(feed)
self.__instrument = instrument
self.__position = None
# self.setUseAdjustedValues(True)
self.__prices = feed[instrument].getPriceDataSeries()
# 指数数据
#self.setUseAdjustedValues(False)
self.__shortsma = ma.SMA(self.__prices, 20)
self.__longsma = ma.SMA(self.__prices, 40)
def __init__(self, feed, instrument,period_1,period_2):
strategy.BacktestingStrategy.__init__(self, feed,1000)
# We want a 15 period SMA over the closing prices.
#self.__sma = ma.SMA(feed[instrument].getCloseDataSeries(), period)
self.__instrument = instrument
self.__position = None
#self.setUseAdjustedValues(True)
self.__feed = feed
self.__time1 = period_1
self.__time2 = period_2
self._t1 = ma.SMA(self.__feed[self.__instrument].getCloseDataSeries(), self.__time1)
self._t2 = ma.SMA(self.__feed[self.__instrument].getCloseDataSeries(), self.__time2)
def __init__(self, feed, instrument, smaShort, smaLong):
strategy.BacktestingStrategy.__init__(self, feed, 1000)
self.__position = None
self.__instrument = instrument
# We'll use adjusted close values instead of regular close values.
self.setUseAdjustedValues(True)
self.__smaShort = ma.SMA(feed[instrument].getPriceDataSeries(),
smaShort)
self.__smaLong = ma.SMA(feed[instrument].getPriceDataSeries(), smaLong)
self.__buffer = 0
self.__trigger = 5
self.getBroker().getFillStrategy().setVolumeLimit(None)
def __init__(self, feed, instrument):
super(MyStrategy, self).__init__(feed)
self.__instrument = instrument
ds = feed.getDataSeries(instrument=instrument,
freq=barcls.Frequency.DAY)
self.atr20 = ptatr.ATR(ds, period=20, maxLen=100)
pds = feed[instrument, barcls.Frequency.DAY].getCloseDataSeries()
self.ma10 = ptma.SMA(pds, period=10, maxLen=30)
self.ma20 = ptma.SMA(pds, period=20, maxLen=60)
self.ma58 = ptma.SMA(pds, period=58, maxLen=150)
self.ma200 = ptma.SMA(pds, period=200, maxLen=250)
def __init__(self, feed, stopPer, stopTrailing, stopFixed, smaShort,
smaLong):
MyBenchmark.__init__(self, feed, stopPer, stopTrailing, stopFixed,
smaLong)
self._smaShort = {}
self._smaLong = {}
for instrument in feed.getRegisteredInstruments():
self._smaShort[instrument] = ma.SMA(
self._feed[instrument].getPriceDataSeries(), smaShort)
self._smaLong[instrument] = ma.SMA(
self._feed[instrument].getPriceDataSeries(), smaLong)
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)
self.__ma1 = ma.SMA(self.__prices, self.__malength1)
self.__ma2 = ma.SMA(self.__prices, self.__malength2)
def __init__(self, feed, smaShort, smaLong):
MyBenchmark.__init__(self, feed, smaLong)
self._smaShort = {}
self._smaLong = {}
self._macdPrice = {}
self._macdVol = {}
for instrument in feed.getRegisteredInstruments():
self._smaShort[instrument] = ma.SMA(self._feed[instrument].getPriceDataSeries(), smaShort)
self._smaLong[instrument] = ma.SMA(self._feed[instrument].getPriceDataSeries(), smaLong)
self._macdPrice[instrument] = macd.MACD(self._feed[instrument].getPriceDataSeries(), 12, 26, 9)
self._macdVol[instrument] = macd.MACD(self._feed[instrument].getVolumeDataSeries(), 12, 26, 9)
def testCrossAboveWithSMA(self):
ds1 = dataseries.SequenceDataSeries()
ds2 = dataseries.SequenceDataSeries()
sma1 = ma.SMA(ds1, 15)
sma2 = ma.SMA(ds2, 25)
for i in range(100):
ds1.append(i)
ds2.append(50)
if i == 58:
self.assertEqual(cross.cross_above(sma1[:], sma2[:], -2, None), 1)
else:
self.assertEqual(cross.cross_above(sma1[:], sma2[:], -2, None), 0)
def __init__(self, feed, entrySMA, exitSMA, rsiPeriod, overBoughtThreshold, overSoldThreshold): initialCash = 2000 strategy.Strategy.__init__(self, feed, initialCash) self.__instrument = feed.getDefaultInstrument() ds = feed.getDataSeries().getCloseDataSeries() self.__entrySMA = ma.SMA(ds, entrySMA) self.__exitSMA = ma.SMA(ds, exitSMA) self.__rsi = rsi.RSI(ds, rsiPeriod) self.__overBoughtThreshold = overBoughtThreshold self.__overSoldThreshold = overSoldThreshold self.__longPos = None self.__shortPos = None
def testWithSMAs(self):
ds1 = dataseries.SequenceDataSeries()
ds2 = dataseries.SequenceDataSeries()
crs = cross.CrossAbove(ma.SMA(ds1, 15), ma.SMA(ds2, 25), 2)
for i in range(100):
ds1.appendValue(i)
ds2.appendValue(50)
if i < 24:
self.assertTrue(crs.getValue() == None)
elif i == 58:
self.assertTrue(crs.getValue() == 1)
else:
self.assertTrue(crs.getValue() == 0)
def __init__(self, feed, instrument, ma1, ma2, ma3, ma4):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
self.__position = None
# We'll use adjusted close values instead of regular close values.
self.setUseAdjustedValues(False)
self.__prices = feed[instrument].getPriceDataSeries()
self.__ma1 = ma.SMA(self.__prices, ma1)
self.__ma2 = ma.SMA(self.__prices, ma2)
self.__ma3 = ma.SMA(self.__prices, ma3)
self.__ma4 = ma.SMA(self.__prices, ma4)
def __init__(self, feed, instrument, smaPeriod, factor1):
super(MyStrategy, self).__init__(feed, 1000000)
self.__position = None
self.__instrument = instrument
# We'll use adjusted close values instead of regular close values.
self.setUseAdjustedValues(True)
self.__sma = ma.SMA(feed[instrument].getPriceDataSeries(), smaPeriod)
self.__rsi = rsi.RSI(feed[instrument].getPriceDataSeries(), smaPeriod)
self.__volsma = ma.SMA(feed[instrument].getVolumeDataSeries(),
smaPeriod)
self.__vol = feed[instrument].getVolumeDataSeries()
self.__chg = ma.SMA(
feed[instrument].getExtraDataSeries(name="pct_chg"), 1)
def __init__(self, feed, instrument, broker, fastMA, slowMA,
takeProfitMultiplier, stopMultiplier):
super(MACrossoverStrategy, self).__init__(feed, broker)
self.__instrument = instrument
self.__fast_ma = ma.SMA(feed[instrument].getPriceDataSeries(), fastMA)
self.__slow_ma = ma.SMA(feed[instrument].getPriceDataSeries(), slowMA)
self.__takeProfitMultiplier = takeProfitMultiplier
self.__stopMultiplier = stopMultiplier
self.__takeProfitPrice = None
self.__stopPrice = None
self.__position = None
self.__lastTrend = None
def __init__(self, feed, stopPer, stopTrailing, smaShort, smaLong, macdPriceShort, macdPriceLong, macdPriceSignal, macdVolShort, macdVolLong, macdVolSignal):
MyBenchmark.__init__(self, feed, stopPer, stopTrailing, smaLong)
self._smaShort = {}
self._smaLong = {}
self._macdPrice = {}
self._macdVol = {}
for instrument in feed.getRegisteredInstruments():
self._smaShort[instrument] = ma.SMA(self._feed[instrument].getPriceDataSeries(), smaShort)
self._smaLong[instrument] = ma.SMA(self._feed[instrument].getPriceDataSeries(), smaLong)
self._macdPrice[instrument] = macd.MACD(self._feed[instrument].getPriceDataSeries(), macdPriceShort, macdPriceLong, macdPriceSignal)
self._macdVol[instrument] = macd.MACD(self._feed[instrument].getVolumeDataSeries(), macdVolShort, macdVolLong, macdVolSignal)
def __init__(self, feed, quandlFeed, instrument):
super(MyStrategy, self).__init__(feed)
self.setUseAdjustedValues(True)
self.__instrument = instrument
self.__position = None
self.__sma_5 = ma.SMA(feed[instrument].getPriceDataSeries(), 5)
self.__sma_10 = ma.SMA(feed[instrument].getPriceDataSeries(), 10)
# It is VERY important to add the the extra feed to the event dispatch loop before
# running the strategy.
self.getDispatcher().addSubject(quandlFeed)
# Subscribe to events from the Quandl feed.
quandlFeed.getNewValuesEvent().subscribe(self.onQuandlData)
def __init__(self,feed,instrument,nfast,nslow): #this is where we have to define the initial budget super(MovingAverageStrategy,self).__init__(feed,INITIAL_BUDGET) #we can track the position: long or short positions #if it is None we know we can open one self.position = None #the given stock (for example AAPL) self.instrument = instrument #if we want to use adjusted closing prices instead of regular closing prices self.setUseAdjustedValues(True) #fast moving average indicator (short-term trend) period is smaller self.fastMA = ma.SMA(feed[instrument].getPriceDataSeries(),nfast) #slow moving average indicator (long-term trend) period is larger self.slowMA = ma.SMA(feed[instrument].getPriceDataSeries(),nslow)
def __init__(self, feed, instrument, entrySMA, exitSMA, rsiPeriod,
overBoughtThreshold, overSoldThreshold):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
# We'll use adjusted close values instead of regular close values.
self.setUseAdjustedValues(True)
self.__priceDS = feed[instrument].getPriceDataSeries()
self.__entrySMA = ma.SMA(self.__priceDS, entrySMA)
self.__exitSMA = ma.SMA(self.__priceDS, exitSMA)
self.__rsi = rsi.RSI(self.__priceDS, rsiPeriod)
self.__overBoughtThreshold = overBoughtThreshold
self.__overSoldThreshold = overSoldThreshold
self.__longPos = None
self.__shortPos = None
def __init__(self, feed, instrument, nfast, nslow):
# define the initial budget
super(MovingAverageStrategy, self).__init__(feed, INITIAL_BUDGET)
#we can track the long or short positions
self.position = None
#the given stock
self.instrument = instrument
# use adjusted closing prices instead of regular closing prices
self.setUseAdjustedValues(True)
#fast moving average indicator
self.fastMA = ma.SMA(feed[instrument].getPriceDataSeries(), nfast)
#slow moving average indicator
self.slowMA = ma.SMA(feed[instrument].getPriceDataSeries(), nslow)
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, instruments, posMax, entrySma, exitSma, rsiPeriod,
overSoldThreshold):
MyBenchmark.__init__(self, feed, instruments, posMax, exitSma)
self._overSoldThreshold = overSoldThreshold
self._prices = {}
self._entrySmas = {}
self._exitSmas = {}
self._rsis = {}
for instrument in instruments:
priceDS = feed[instrument].getPriceDataSeries()
self._prices[instrument] = priceDS
self._entrySmas[instrument] = ma.SMA(priceDS, entrySma)
self._exitSmas[instrument] = ma.SMA(priceDS, exitSma)
self._rsis[instrument] = rsi.RSI(priceDS, rsiPeriod)
def __init__(self, feed, instrument, bBandsPeriod, smaPeriod_short,
smaPeriod_long, slope_period):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
self.__prices = feed[instrument].getPriceDataSeries()
self.__sma_short = ma.SMA(self.__prices, smaPeriod_short)
self.__sma_long = ma.SMA(self.__prices, smaPeriod_long)
self.__bbands = bollinger.BollingerBands(
feed[instrument].getCloseDataSeries(), bBandsPeriod, 2)
self.__slope = linreg.Slope(self.__prices, slope_period)
self.__middle_slope = linreg.Slope(self.__bbands.getMiddleBand(),
slope_period)
self.__longPos = None
self.__shortPos = None
self.slope_period = slope_period
def __init__(self, feed, instrument, entrySMA, exitSMA, rsiPeriod, overBoughtThreshold, overSoldThreshold):
super(RSI2, self).__init__(feed)
self.__instrument = instrument
# We'll use adjusted close values, if available, instead of regular
# close values.
if feed.barsHaveAdjClose():
self.setUseAdjustedValues(True)
self.__priceDS = feed[instrument].getPriceDataSeries()
self.__entrySMA = ma.SMA(self.__priceDS, entrySMA)
self.__exitSMA = ma.SMA(self.__priceDS, exitSMA)
self.__rsi = rsi.RSI(self.__priceDS, rsiPeriod)
self.__overBoughtThreshold = overBoughtThreshold
self.__overSoldThreshold = overSoldThreshold
self.__longPos = None
self.__shortPos = None
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, leadInstrument, lagInstrument, smaPeriod):
_, self.__priceCurrency = leadInstrument.split("/")
strategy.BacktestingStrategy.__init__(
self, feed, balances={self.__priceCurrency: 1e6})
assert (smaPeriod > 3)
self.__lead = leadInstrument
self.__lag = lagInstrument
self.__adjClose = feed.getDataSeries(
self.__lead).getAdjCloseDataSeries()
# Exit signal is more sensitive than entry.
self.__fastSMA = ma.SMA(self.__adjClose, int(smaPeriod / 2))
self.__slowSMA = ma.SMA(self.__adjClose, smaPeriod)
self.__pos = None
