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