def __init__(self, dataSeries, period, numStdDev, maxLen=None):
self.__sma = ma.SMA(dataSeries, period, maxLen=maxLen)
self.__stdDev = stats.StdDev(dataSeries, period, maxLen=maxLen)
self.__upperBand = dataseries.SequenceDataSeries(maxLen)
self.__lowerBand = dataseries.SequenceDataSeries(maxLen)
self.__numStdDev = numStdDev
# It is important to subscribe after sma and stddev since we'll use those values.
dataSeries.getNewValueEvent().subscribe(self.__onNewValue)
def testIncremental(self):
size = 20
ds1 = dataseries.SequenceDataSeries()
ds2 = dataseries.SequenceDataSeries()
ads1, ads2 = aligned.datetime_aligned(ds1, ds2)
now = datetime.datetime.now()
for i in range(size):
ds1.appendWithDateTime(now + datetime.timedelta(seconds=i), i)
ds2.appendWithDateTime(now + datetime.timedelta(seconds=i), i)
self.assertEqual(len(ads1), len(ads2))
self.assertEqual(ads1[:], ads2[:])
self.assertEqual(ads1.getDateTimes()[:], ads2.getDateTimes()[:])
def testBoundedSources(self):
ds1 = dataseries.SequenceDataSeries(1)
ds2 = dataseries.SequenceDataSeries(1)
ads1, ads2 = aligned.datetime_aligned(ds1, ds2)
now = datetime.datetime.now()
ds1.appendWithDateTime(now + datetime.timedelta(seconds=1), 1)
ds1.appendWithDateTime(now + datetime.timedelta(seconds=2), 2)
ds1.appendWithDateTime(now + datetime.timedelta(seconds=3), 3)
ds2.appendWithDateTime(now + datetime.timedelta(seconds=2), 2)
ds2.appendWithDateTime(now + datetime.timedelta(seconds=3), 3)
ds2.appendWithDateTime(now + datetime.timedelta(seconds=4), 4)
self.assertEqual(ads1[:], [2, 3])
self.assertEqual(ads2[:], [2, 3])
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 testSeqLikeOps(self):
seq = range(10)
ds = dataseries.SequenceDataSeries()
for value in seq:
ds.append(value)
# Test length and every item.
self.assertEqual(len(ds), len(seq))
for i in xrange(len(seq)):
self.assertEqual(ds[i], seq[i])
# Test negative indices
self.assertEqual(ds[-1], seq[-1])
self.assertEqual(ds[-2], seq[-2])
self.assertEqual(ds[-9], seq[-9])
# Test slices
sl = slice(0, 1, 2)
self.assertEqual(ds[sl], seq[sl])
sl = slice(0, 9, 2)
self.assertEqual(ds[sl], seq[sl])
sl = slice(0, -1, 1)
self.assertEqual(ds[sl], seq[sl])
for i in xrange(-100, 100):
self.assertEqual(ds[i:], seq[i:])
for step in xrange(1, 10):
for i in xrange(-100, 100):
self.assertEqual(ds[i::step], seq[i::step])
def testMaxLen(self):
ds = dataseries.SequenceDataSeries()
for i in range(3000):
ds.append(i)
self.assertEqual(len(ds), 2048)
self.assertEqual(ds[0], 952)
self.assertEqual(ds[-1], 2999)
def testStraightLine(self):
seqDS = dataseries.SequenceDataSeries()
lsReg = linreg.LeastSquaresRegression(seqDS, 3)
nextDateTime = datetime.datetime(2012, 1, 1)
seqDS.appendWithDateTime(nextDateTime, 1)
self.assertEqual(lsReg[-1], None)
nextDateTime = nextDateTime + datetime.timedelta(hours=1)
seqDS.appendWithDateTime(nextDateTime, 2)
self.assertEqual(lsReg[-1], None)
# Check current value.
nextDateTime = nextDateTime + datetime.timedelta(hours=1)
seqDS.appendWithDateTime(nextDateTime, 3)
self.assertEqual(round(lsReg[-1], 2), 3)
# Check future values.
futureDateTime = nextDateTime + datetime.timedelta(hours=1)
self.assertEqual(round(lsReg.getValueAt(futureDateTime), 2), 4)
futureDateTime = futureDateTime + datetime.timedelta(minutes=30)
self.assertEqual(round(lsReg.getValueAt(futureDateTime), 2), 4.5)
futureDateTime = futureDateTime + datetime.timedelta(minutes=30)
self.assertEqual(round(lsReg.getValueAt(futureDateTime), 2), 5)
# Move forward in sub-second increments.
nextDateTime = nextDateTime + datetime.timedelta(milliseconds=50)
seqDS.appendWithDateTime(nextDateTime, 4)
nextDateTime = nextDateTime + datetime.timedelta(milliseconds=50)
seqDS.appendWithDateTime(nextDateTime, 5)
self.assertEqual(round(lsReg[-1], 2), 5)
def testBounded(self):
ds = dataseries.SequenceDataSeries(maxLen=2)
for i in xrange(100):
ds.append(i)
if i > 0:
self.assertEqual(ds[0], i - 1)
self.assertEqual(ds[1], i)
self.assertEqual(len(ds), 2)
def testStdDev_1(self):
values = [1, 1, 2, 3, 5]
seqDS = dataseries.SequenceDataSeries()
stdDev = stats.StdDev(seqDS, 1)
for value in values:
seqDS.append(value)
for i in stdDev:
self.assertEqual(i, 0)
def datetime_aligned(ds1, ds2, maxLen=None):
"""
Returns two dataseries that exhibit only those values whose datetimes are in both dataseries.
:param ds1: A DataSeries instance.
:type ds1: :class:`DataSeries`.
:param ds2: A DataSeries instance.
:type ds2: :class:`DataSeries`.
:param maxLen: The maximum number of values to hold for the returned :class:`DataSeries`.
Once a bounded length is full, when new items are added, a corresponding number of items are discarded from the
opposite end. If None then dataseries.DEFAULT_MAX_LEN is used.
:type maxLen: int.
"""
aligned1 = dataseries.SequenceDataSeries(maxLen)
aligned2 = dataseries.SequenceDataSeries(maxLen)
Syncer(ds1, ds2, aligned1, aligned2)
return (aligned1, aligned2)
def testStdDev_Bounded(self):
values = [1, 1, 2, 3, 5]
seqDS = dataseries.SequenceDataSeries()
stdDev = stats.StdDev(seqDS, 2, maxLen=2)
for value in values:
seqDS.append(value)
self.assertEqual(stdDev[0], numpy.array([2, 3]).std())
self.assertEqual(stdDev[1], numpy.array([3, 5]).std())
def testFullyAligned(self):
size = 20
ds1 = dataseries.SequenceDataSeries()
ds2 = dataseries.SequenceDataSeries()
ads1, ads2 = aligned.datetime_aligned(ds1, ds2)
now = datetime.datetime.now()
for i in range(size):
ds1.appendWithDateTime(now + datetime.timedelta(seconds=i), i)
ds2.appendWithDateTime(now + datetime.timedelta(seconds=i), i)
self.assertEqual(len(ds1), len(ds2))
for ads in [ads1, ads2]:
self.assertEqual(len(ads), size)
for i in range(size):
self.assertEqual(ads.getValueAbsolute(i), i)
self.assertEqual(ads.getDateTimes()[i],
now + datetime.timedelta(seconds=i))
def __init__(self, dataSeries, fastEMA, slowEMA, signalEMA, maxLen=None):
assert (fastEMA > 0)
assert (slowEMA > 0)
assert (fastEMA < slowEMA)
assert (signalEMA > 0)
super(MACD, self).__init__(maxLen)
# We need to skip some values when calculating the fast EMA in order for both EMA
# to calculate their first values at the same time.
# I'M FORCING THIS BEHAVIOUR ONLY TO MAKE THIS FITLER MATCH TA-Lib MACD VALUES.
self.__fastEMASkip = slowEMA - fastEMA
self.__fastEMAWindow = ma.EMAEventWindow(fastEMA)
self.__slowEMAWindow = ma.EMAEventWindow(slowEMA)
self.__signalEMAWindow = ma.EMAEventWindow(signalEMA)
self.__signal = dataseries.SequenceDataSeries(maxLen)
self.__histogram = dataseries.SequenceDataSeries(maxLen)
dataSeries.getNewValueEvent().subscribe(self.__onNewValue)
def testEventWindow(self):
ds = dataseries.SequenceDataSeries()
smaEW = ma.SMAEventWindow(10)
sma = ma.SMA(ds, 10)
smaEW.onNewValue(None, None) # This value should get skipped
for i in xrange(100):
ds.append(i)
smaEW.onNewValue(None, i)
self.assertEqual(sma[-1], smaEW.getValue())
smaEW.onNewValue(None, None) # This value should get skipped
def testNotAligned(self):
size = 20
ds1 = dataseries.SequenceDataSeries()
ds2 = dataseries.SequenceDataSeries()
ads1, ads2 = aligned.datetime_aligned(ds1, ds2)
now = datetime.datetime.now()
for i in range(size):
if i % 2 == 0:
ds1.appendWithDateTime(now + datetime.timedelta(seconds=i), i)
else:
ds2.appendWithDateTime(now + datetime.timedelta(seconds=i), i)
self.assertEqual(len(ds1), len(ds2))
for ads in [ads1, ads2]:
self.assertEqual(len(ads), 0)
self.assertEqual(ads.getValueAbsolute(0), None)
self.assertEqual(ads.getDateTimes(), [])
def testEmpty(self):
ds = dataseries.SequenceDataSeries()
self.assertTrue(len(ds) == 0)
with self.assertRaises(IndexError):
ds[-1]
with self.assertRaises(IndexError):
ds[-2]
with self.assertRaises(IndexError):
ds[0]
with self.assertRaises(IndexError):
ds[1]
def testZScore(self):
values = [1.10, 2.20, 4.00, 5.10, 6.00, 7.10, 8.20, 9.00, 10.10, 3.00, 4.10, 5.20, 7.00, 8.10, 9.20, 16.00, 17.10, 18.20, 19.30, 20.40]
expected = [None, None, None, None, 1.283041407, 1.317884611, 1.440611043, 1.355748299, 1.4123457, -1.831763202, -0.990484842, -0.388358578, 0.449889908, 1.408195169, 1.332948099, 1.867732104, 1.334258333, 1.063608066, 0.939656572, 1.414213562]
seqDS = dataseries.SequenceDataSeries()
zscore = stats.ZScore(seqDS, 5)
i = 0
for value in values:
seqDS.append(value)
if i >= 4:
self.assertEqual(round(zscore[-1], 4), round(expected[i], 4))
i += 1
def testStdDev(self):
values = [1, 1, 2, 3, 5]
seqDS = dataseries.SequenceDataSeries()
stdDev = stats.StdDev(seqDS, 2)
for value in values:
seqDS.append(value)
self.assertEqual(stdDev[0], None)
self.assertEqual(stdDev[1], numpy.array([1, 1]).std())
self.assertEqual(stdDev[2], numpy.array([1, 2]).std())
self.assertEqual(stdDev[3], numpy.array([2, 3]).std())
self.assertEqual(stdDev[4], numpy.array([3, 5]).std())
def testCumRet(self):
values = dataseries.SequenceDataSeries()
rets = cumret.CumulativeReturn(values)
for value in [1, 2, 3, 4, 4, 3, 1, 1.2]:
values.append(value)
self.assertEqual(rets[0], None)
self.assertEqual(rets[1], 1)
self.assertEqual(rets[2], 2)
self.assertEqual(rets[3], 3)
self.assertEqual(rets[4], 3)
self.assertEqual(rets[5], 2)
self.assertEqual(rets[6], 0)
self.assertEqual(round(rets[7], 1), 0.2)
def testPartiallyAligned(self):
size = 20
commonDateTimes = []
ds1 = dataseries.SequenceDataSeries()
ds2 = dataseries.SequenceDataSeries()
ads1, ads2 = aligned.datetime_aligned(ds1, ds2)
now = datetime.datetime.now()
for i in range(size):
if i % 3 == 0:
commonDateTimes.append(now + datetime.timedelta(seconds=i))
ds1.appendWithDateTime(now + datetime.timedelta(seconds=i), i)
ds2.appendWithDateTime(now + datetime.timedelta(seconds=i), i)
elif i % 2 == 0:
ds1.appendWithDateTime(now + datetime.timedelta(seconds=i), i)
else:
ds2.appendWithDateTime(now + datetime.timedelta(seconds=i), i)
self.assertEqual(len(ads1), len(ads2))
self.assertEqual(ads1[:], ads2[:])
self.assertEqual(ads1.getDateTimes(), commonDateTimes)
self.assertEqual(ads2.getDateTimes(), commonDateTimes)
def testResize1(self):
ds = dataseries.SequenceDataSeries(100)
for i in xrange(100):
ds.append(i)
self.assertEqual(len(ds), 100)
self.assertEqual(len(ds.getDateTimes()), 100)
self.assertEqual(ds[0], 0)
self.assertEqual(ds[-1], 99)
ds.setMaxLen(2)
self.assertEqual(len(ds), 2)
self.assertEqual(len(ds.getDateTimes()), 2)
self.assertEqual(ds[0], 98)
self.assertEqual(ds[1], 99)
def __init__(self, maxLen=None):
super(BarDataSeries, self).__init__(maxLen)
self.__openDS = dataseries.SequenceDataSeries(maxLen)
self.__closeDS = dataseries.SequenceDataSeries(maxLen)
self.__highDS = dataseries.SequenceDataSeries(maxLen)
self.__lowDS = dataseries.SequenceDataSeries(maxLen)
self.__volumeDS = dataseries.SequenceDataSeries(maxLen)
self.__adjCloseDS = dataseries.SequenceDataSeries(maxLen)
self.__extraDS = {}
self.__useAdjustedValues = False
def testBoundedFilter(self):
values = [
22.2734, 22.1940, 22.0847, 22.1741, 22.1840, 22.1344, 22.2337,
22.4323, 22.2436, 22.2933, 22.1542, 22.3926, 22.3816, 22.6109,
23.3558, 24.0519, 23.7530, 23.8324, 23.9516, 23.6338, 23.8225,
23.8722, 23.6537, 23.1870, 23.0976, 23.3260, 22.6805, 23.0976,
22.4025, 22.1725
]
seqDS = dataseries.SequenceDataSeries()
ema = ma.EMA(seqDS, 10, 2)
for value in values:
seqDS.append(value)
self.assertEqual(round(ema[0], 5), 23.08068)
self.assertEqual(round(ema[1], 5), 22.91556)
self.assertEqual(len(ema), 2)
self.assertEqual(len(ema[:]), 2)
self.assertEqual(len(ema.getDateTimes()), 2)
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 testNonEmpty(self):
ds = dataseries.SequenceDataSeries()
for value in range(10):
ds.append(value)
self.assertTrue(len(ds) == 10)
self.assertTrue(ds[-1] == 9)
self.assertTrue(ds[-2] == 8)
self.assertTrue(ds[0] == 0)
self.assertTrue(ds[1] == 1)
self.assertTrue(ds[-1:] == [9])
self.assertTrue(ds[-2:] == [8, 9])
self.assertTrue(ds[-2:-1] == [8])
self.assertTrue(ds[-3:-1] == [7, 8])
self.assertTrue(ds[1:4] == [1, 2, 3])
self.assertTrue(ds[9:10] == [9])
self.assertTrue(ds[9:11] == [9])
self.assertTrue(ds[9:] == [9])
def testInvalidPosNotCached(self):
ds = dataseries.SequenceDataSeries()
testFilter = TestFilter(ds)
for i in range(10):
ds.append(i)
ds.append(None) # Interleave Nones.
self.assertEqual(testFilter[-1], None)
self.assertEqual(testFilter[-2], 9)
self.assertEqual(
testFilter[-4], 8
) # We go 3 instead of 2 because we need to skip the interleaved None values.
self.assertEqual(testFilter[18], 9)
self.assertEqual(testFilter[19], None)
# Absolut pos 20 should have the next value once we insert it, but right now it should be invalid.
with self.assertRaises(IndexError):
testFilter[20]
ds.append(10)
self.assertEqual(testFilter[20], 10)
def testMACD(self):
values = [
16.39, 16.4999, 16.45, 16.43, 16.52, 16.51, 16.423, 16.41, 16.47,
16.45, 16.32, 16.36, 16.34, 16.59, 16.54, 16.52, 16.44, 16.47,
16.5, 16.45, 16.28, 16.07, 16.08, 16.1, 16.1, 16.09, 16.43,
16.4899, 16.59, 16.65, 16.78, 16.86, 16.86, 16.76
]
# These expected values were generated using TA-Lib
macdValues = [
None, None, None, None, None, None, None, None, None, None, None,
None, None, None, None, None, None, 0.0067, 0.0106, 0.0028,
-0.0342, -0.0937, -0.1214, -0.1276, -0.125, -0.1195, -0.0459,
0.0097, 0.0601, 0.0975, 0.139, 0.1713, 0.1816, 0.1598
]
signalValues = [
None, None, None, None, None, None, None, None, None, None, None,
None, None, None, None, None, None, 0.0036, 0.0056, 0.0048,
-0.0064, -0.0313, -0.057, -0.0772, -0.0909, -0.0991, -0.0839,
-0.0571, -0.0236, 0.011, 0.0475, 0.0829, 0.1111, 0.125
]
histogramValues = [
None, None, None, None, None, None, None, None, None, None, None,
None, None, None, None, None, None, 0.0031, 0.005, -0.002, -0.0279,
-0.0624, -0.0643, -0.0504, -0.0342, -0.0205, 0.0379, 0.0668,
0.0838, 0.0865, 0.0914, 0.0884, 0.0705, 0.0348
]
ds = dataseries.SequenceDataSeries()
macdDs = macd.MACD(ds, 5, 13, 6)
for i, value in enumerate(values):
ds.append(value)
self.assertEqual(common.safe_round(macdDs[i], 4), macdValues[i])
self.assertEqual(common.safe_round(macdDs.getSignal()[i], 4),
signalValues[i])
self.assertEqual(common.safe_round(macdDs.getHistogram()[i], 4),
histogramValues[i])
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 __buildRSI(self, values, period, rsiMaxLen=None):
seqDS = dataseries.SequenceDataSeries()
ret = rsi.RSI(seqDS, period, rsiMaxLen)
for value in values:
seqDS.append(value)
return ret
def testInvalidThreshold(self):
seqDS = dataseries.SequenceDataSeries()
with self.assertRaisesRegexp(Exception, "Invalid thresholds"):
linreg.Trend(seqDS, 10, 0.2, 0.5, 5)
