def testStockChartsBollinger(self):
# Test data from http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:bollinger_bands
prices = [
86.1557, 89.0867, 88.7829, 90.3228, 89.0671, 91.1453, 89.4397, 89.1750, 86.9302, 87.6752, 86.9596,
89.4299, 89.3221, 88.7241, 87.4497, 87.2634, 89.4985, 87.9006, 89.1260, 90.7043, 92.9001, 92.9784,
91.8021, 92.6647, 92.6843, 92.3021, 92.7725, 92.5373, 92.9490, 93.2039, 91.0669, 89.8318, 89.7435,
90.3994, 90.7387, 88.0177, 88.0867, 88.8439, 90.7781, 90.5416, 91.3894, 90.6500
]
expectedMiddle = [
88.71, 89.05, 89.24, 89.39, 89.51, 89.69, 89.75, 89.91, 90.08, 90.38, 90.66, 90.86, 90.88, 90.91,
90.99, 91.15, 91.19, 91.12, 91.17, 91.25, 91.24, 91.17, 91.05
]
expectedUpper = [
91.29, 91.95, 92.61, 92.93, 93.31, 93.73, 93.90, 94.27, 94.57, 94.79, 95.04, 94.91, 94.90, 94.90,
94.86, 94.67, 94.56, 94.68, 94.58, 94.53, 94.53, 94.37, 94.15
]
expectedLower = [
86.12, 86.14, 85.87, 85.85, 85.70, 85.65, 85.59, 85.56, 85.60, 85.98, 86.27, 86.82, 86.87, 86.91,
87.12, 87.63, 87.83, 87.56, 87.76, 87.97, 87.95, 87.96, 87.95
]
seqDS = dataseries.SequenceDataSeries()
bBands = bollinger.BollingerBands(seqDS, 20, 2)
for value in prices:
seqDS.append(value)
for i in xrange(19):
self.assertEqual(bBands.getMiddleBand()[i], None)
self.assertEqual(bBands.getUpperBand()[i], None)
self.assertEqual(bBands.getLowerBand()[i], None)
for i in xrange(19, len(seqDS)):
self.assertEqual(round(bBands.getMiddleBand()[i], 2), expectedMiddle[i-19])
self.assertEqual(round(bBands.getUpperBand()[i], 2), expectedUpper[i-19])
self.assertEqual(round(bBands.getLowerBand()[i], 2), expectedLower[i-19])
def __init__(self, feed, instrument, bBandsPeriod):
"""
"""
super(BBands, self).__init__(feed)
self.__instrument = instrument
self.__bbands = bollinger.BollingerBands(
feed[instrument].getCloseDataSeries(), bBandsPeriod, 2)
def __init__(self, feed, instrument, bBandsPeriod, numStdevs):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
# We'll use adjusted close values instead of regular close values.
self.setUseAdjustedValues(True)
self.__bbands = bollinger.BollingerBands(
feed[instrument].getAdjCloseDataSeries(), bBandsPeriod, numStdevs)
def testStockChartsBollinger_Bounded(self):
# Test data from http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:bollinger_bands
prices = [
86.1557, 89.0867, 88.7829, 90.3228, 89.0671, 91.1453, 89.4397, 89.1750, 86.9302, 87.6752, 86.9596,
89.4299, 89.3221, 88.7241, 87.4497, 87.2634, 89.4985, 87.9006, 89.1260, 90.7043, 92.9001, 92.9784,
91.8021, 92.6647, 92.6843, 92.3021, 92.7725, 92.5373, 92.9490, 93.2039, 91.0669, 89.8318, 89.7435,
90.3994, 90.7387, 88.0177, 88.0867, 88.8439, 90.7781, 90.5416, 91.3894, 90.6500
]
expectedMiddle = [91.24, 91.17, 91.05]
expectedUpper = [94.53, 94.37, 94.15]
expectedLower = [87.95, 87.96, 87.95]
seqDS = dataseries.SequenceDataSeries()
bBands = bollinger.BollingerBands(seqDS, 20, 2, 3)
for value in prices:
seqDS.append(value)
for i in xrange(3):
self.assertEqual(round(bBands.getMiddleBand()[i], 2), expectedMiddle[i])
self.assertEqual(round(bBands.getUpperBand()[i], 2), expectedUpper[i])
self.assertEqual(round(bBands.getLowerBand()[i], 2), expectedLower[i])
self.assertEqual(len(bBands.getMiddleBand()), 3)
self.assertEqual(len(bBands.getMiddleBand()[:]), 3)
self.assertEqual(len(bBands.getMiddleBand().getDateTimes()), 3)
self.assertEqual(len(bBands.getUpperBand()), 3)
self.assertEqual(len(bBands.getUpperBand()[:]), 3)
self.assertEqual(len(bBands.getUpperBand().getDateTimes()), 3)
self.assertEqual(len(bBands.getLowerBand()), 3)
self.assertEqual(len(bBands.getLowerBand()[:]), 3)
self.assertEqual(len(bBands.getLowerBand().getDateTimes()), 3)
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, strategy,feed, instrument, bBandsPeriod):
self.__instrument = instrument
self.__prices = feed[instrument].getPriceDataSeries()
self.__position = None#remove later
self.__bbands = bollinger.BollingerBands(feed[instrument].getCloseDataSeries(), bBandsPeriod, 2)
#self.__bbands = bollinger.BollingerBands(feed[instrument].getCloseDataSeries(), bBandsPeriod, 1)
self.__strategy= strategy
self.__trend = TrendRatio(self.__prices,20)
self.plot_init(True)
def __init__(self, feed, broker, instrument, bBandsPeriod):
super(BBands, self).__init__(feed, brk=broker)
self.__instrument = instrument
self.__symbol, self.__priceCurrency = instrument.split("/")
self.__bbands = bollinger.BollingerBands(
feed.getDataSeries(instrument).getCloseDataSeries(),
bBandsPeriod, 2
)
def __init__(self, feed, instrument, bBandsPeriod, overBoughtThreshold,
overSoldThreshold):
super(BBands, self).__init__(feed)
self.__instrument = instrument
self.__bbands = bollinger.BollingerBands(
feed[instrument].getCloseDataSeries(), bBandsPeriod, 2)
self.__rsi = rsi.RSI(feed[instrument].getCloseDataSeries(), 14)
self.overBoughtThreshold = overBoughtThreshold
self.overSoldThreshold = overSoldThreshold
def initIndicators(self):
#mid 3)
self.__bbands = {}
for instrument in self.instruments:
self.__bbands[instrument] = bollinger.BollingerBands(
self.closePrices[instrument],
self.__period,
self.__numStd,
maxLen=self.mid_DEFAULT_MAX_LEN)
def __init__(self, feed, instrument, initialCash, period, width):
super(BollingerStrategy, self).__init__(feed, initialCash)
self.__position = None
self.setUseAdjustedValues(True)
self.__bollinger = bollinger.BollingerBands(feed[instrument].getCloseDataSeries(), period, width)
self.__instrument = instrument
self.__previousClose = None
self.date = []
self.upper = []
self.middle = []
self.lower = []
def __init__(self, feed, instrument):
strategy.BacktestingStrategy.__init__(self, feed)
sigma = 2
self.__bband = bollinger.BollingerBands(
feed[instrument].getCloseDataSeries(), 15, sigma)
self.__bbandLow = self.__bband.getLowerBand()
self.__bbandMiddle = self.__bband.getMiddleBand()
self.__bbandUpper = self.__bband.getUpperBand()
self.__instrument = instrument
self.__position = None
self.getBroker()
def __init__(self,
feed,
instrument,
bBandsPeriod,
cash=10,
comission=0.002):
broker = backtesting.Broker(cash, feed,
backtesting.TradePercentage(comission))
strategy.BaseStrategy.__init__(self, feed, broker)
self.__instrument = instrument
self.__bbands = bollinger.BollingerBands(
feed[instrument].getCloseDataSeries(), bBandsPeriod, 2)
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, instruments, bBandsPeriod):
super(BBands, self).__init__(feed)
self.__instrument = instruments
self.__bbands = [bollinger.BollingerBands(feed[ins].getCloseDataSeries(), bBandsPeriod, 2) for ins in instruments]
# 准备csv文件
self.__file = xlwt.Workbook(encoding='utf-8')
self.__sheets = [self.__file.add_sheet(str(ins)) for ins in instruments]
self.__sheetindex = 1
row0 = [u'datetime', u'lower', u'middle', u'upper', u'price']
for i in range(0, len(row0)):
for ins in range(len(instruments)):
self.__sheets[ins].write(0, i, row0[i])
def __init__(self, feed, instrument, bBandsPeriod):
strategy.BacktestingStrategy.__init__(self, feed)
self.setDebugMode(False)
self.__instrument = instrument
self.__feed = feed
self.__position = None
self.__bbands = bollinger.BollingerBands(
feed[instrument].getCloseDataSeries(), bBandsPeriod, 2)
self.__col = [
"buyPrice", "buyTime", "sellPrice", "sellTime", "returns"
]
self.__msdf = pd.DataFrame(columns=self.__col)
self.__buyPrice = 0
self.__buyTime = None
self.setUseAdjustedValues(True)
def __init__(self, feed, instrument1, instrument2, instrument3,
bBandsPeriod, brk):
#传入变量
# feed---每一个交易日的数据
# instrument1-----价差
# instrument2-----沪金
# instrument3-----COMEX黄金
# bBandsPeriod----布林带的均线周期长度
# brk-------------订单的情况
super(BBands, self).__init__(feed, brk)
self.__instrument1 = instrument1
self.__instrument2 = instrument2
self.__instrument3 = instrument3
self.__bbands = bollinger.BollingerBands(
feed[instrument1].getCloseDataSeries(), bBandsPeriod,
1.5) #获取布林带的指令
self.getBroker() #调用订单的设置
def __init__(self, strategy, feed, instrument, **kwargs):
'''
:param strategy:
:param feed:
:param instrument:
:param bBandsPeriod: ##
:param kwargs:
from signals import baseSignal
std:
'''
super(bband_signal, self).__init__(strategy, feed, instrument)
self.set_member('period', 20, kwargs)
self.set_member('std', 2, kwargs)
self.__position = None #remove later
self.__bbands = bollinger.BollingerBands(
feed[instrument].getCloseDataSeries(), self.period, self.std)
self.__trend = TrendRatio(self.prices, 20)
self.plot_init(True)
def __init__(self, feed, instrument, smaPeriod):
super(MyStrategy, self).__init__(feed, 1000)
self.__position = None
self.__instrument = instrument
# We'll use adjusted close values instead of regular close values.
self.setUseAdjustedValues(True)
## Add calculators
self.__calculators = {
'sma':
ma.SMA(feed[instrument].getPriceDataSeries(), smaPeriod),
'bol':
bollinger.BollingerBands(feed[instrument].getPriceDataSeries(),
smaPeriod, 1),
'ta_dpo':
technical.EventBasedFilter(feed[instrument].getPriceDataSeries(),
indicators.Ta_dpo(40)),
'ta_tsi':
technical.EventBasedFilter(feed[instrument].getPriceDataSeries(),
indicators.Ta_tsi(40)),
'ta_trix':
technical.EventBasedFilter(feed[instrument].getPriceDataSeries(),
indicators.Ta_trix(40))
}
## Add indicators
self.__indicators = {
'sma':
lambda: self._MyStrategy__calculators['sma'][-1],
'bol_low':
lambda: self._MyStrategy__calculators['bol'].getLowerBand()[-1],
'bol_mid':
lambda: self._MyStrategy__calculators['bol'].getMiddleBand()[-1],
'bol_high':
lambda: self._MyStrategy__calculators['bol'].getUpperBand()[-1],
'ta_dpo':
lambda: self._MyStrategy__calculators['ta_dpo'][-1],
'ta_tsi':
lambda: self._MyStrategy__calculators['ta_dpo'][-1],
'ta_trix':
lambda: self._MyStrategy__calculators['ta_dpo'][-1]
}
def __init__(self, feed, companyID, smaPeriod, rsiPeriod, invest_amount):
strategy.BacktestingStrategy.__init__(self, feed, invest_amount)
self.__sma = ma.SMA(
feed.getDataSeries(companyID).getCloseDataSeries(), smaPeriod)
self.__sma60 = ma.SMA(
feed.getDataSeries(companyID).getCloseDataSeries(), 60)
self.__sma90 = ma.SMA(
feed.getDataSeries(companyID).getCloseDataSeries(), 90)
self.__rsi = rsi.RSI(
feed.getDataSeries(companyID).getCloseDataSeries(), rsiPeriod)
self.__bbands = bollinger.BollingerBands(
feed[companyID].getCloseDataSeries(), bBandsPeriod, 2)
self.__position = None
self.__boxFloor = 1000
self.__boxCeiling = 0
self.__cmpID = companyID
self.__amount = invest_amount
self.__strengthIndex = None
self.__discount = None
self.__fee = 0
self.__lastStatus = False
self.__cross_lower = 0
self.__buyin_price = 0
def __init__(self, feed, instrument, hurstPeriod, stdMultiplier, bollingerBandsPeriod, bollingerBandsNoOfStd, slowSmaPeriod, fastSmaPeriod):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = instrument
self.__hurstPeriod = hurstPeriod
self.__calibratedStdMultiplier = stdMultiplier
self.__position = None
# Use adjusted close values, if available, instead of regular close values.
if feed.barsHaveAdjClose():
self.setUseAdjustedValues(True)
self.__adjClosePrices = feed[instrument].getAdjCloseDataSeries()
self.__priceDS = feed[instrument].getPriceDataSeries()
self.__hurst = MovingHurst.HurstExponent(self.__adjClosePrices, hurstPeriod)
self.__movingStatHelper = MovingStatUtil.MovingStatHelper(self.__adjClosePrices, hurstPeriod)
self.__bollingerBandsPeriod = bollingerBandsPeriod
self.__bollingerBandsNoOfStd = bollingerBandsNoOfStd
self.__bollingerBands = bollinger.BollingerBands(self.__adjClosePrices,
self.__bollingerBandsPeriod, self.__bollingerBandsNoOfStd)
self.__slowSma = ma.SMA(self.__priceDS, slowSmaPeriod)
self.__fastSma = ma.SMA(self.__priceDS, fastSmaPeriod)
self.__position = None
def __init__(self, feed, instrument, parametres, cash=10, comission=0.002):
broker = backtesting.Broker(cash, feed, backtesting.TradePercentage(comission))
strategy.BaseStrategy.__init__(self, feed, broker)
self.numOrder = 0
self.okOrder = 0
self.exitOrder = 0
self.s1 = self.s2 = self.s3 = 1
self.p1 = self.p2 = self.p3 = 1
self.windowTrust = parametres[3]
# SMA
self.__instrument = instrument
self.__position = None
self.__Close = feed[instrument].getCloseDataSeries()
self.__sma = ma.SMA(self.__Close, parametres[0])
# Bbands
self.__instrument = instrument
self.__bbands = bollinger.BollingerBands(feed[instrument].getCloseDataSeries(), parametres[1], 2)
# Vwap
self.__instrument = instrument
self.__vwap = vwap.VWAP(feed[instrument], parametres[2])
def __init__(self, feed, instrument, bBandsPeriod):
super(MyStrategy, self).__init__(feed)
self.__instrument = instrument
# 使用调整后的数据
if feed.barsHaveAdjClose():
self.setUseAdjustedValues(True)
# 持有仓位
self.__holdPosition = 0.0
# 空闲仓位
self.__emptyPosition = 10.0
# 单元持仓金额
self.__unit = self.getBroker().getCash(False) / 10
# 统计收盘价
self.__priceDS = feed[instrument].getPriceDataSeries()
# 计算macd指标
self.__macd = macd.MACD(self.__priceDS, 12, 26, 9)
# 计算KD指标
self.__stoch = stoch.StochasticOscillator(feed[instrument], 9, 3)
# 计算rsi指标
self.__rsi7 = rsi.RSI(self.__priceDS, 7)
self.__rsi14 = rsi.RSI(self.__priceDS, 14)
# 计算布林线
self.__bbands = bollinger.BollingerBands(self.__priceDS, bBandsPeriod,
2)
def __init__(self, feed, instrument, calibratedBollingerBandsPeriod):
super(BollingerBandsStrategy, self).__init__(feed, 1000000)
self.__instrument = instrument
self.__bbands = bollinger.BollingerBands(
feed[instrument].getCloseDataSeries(),
calibratedBollingerBandsPeriod, 2)
def __init__(self, feed, instrument, nper, nstdev):
super(BBStrategy, self).__init__(feed)
self.position = None
self.instrument = instrument
self.bbands = bollinger.BollingerBands(
feed[instrument].getPriceDataSeries(), nper, nstdev)
def initIndicators(self):
#mid 3)
self.__bbands = bollinger.BollingerBands(
self.closePrices, 20, 2, maxLen=self.mid_DEFAULT_MAX_LEN)
def __init__(self, feed, code, bBandsPeriod):
strategy.BacktestingStrategy.__init__(self, feed)
self.__instrument = code
self.__bbands = bollinger.BollingerBands(feed[code], bBandsPeriod, 2)
