def testRSubOperator(self):
ma20 = MovingAverage(20, 'close')
sumTotal = Sum('close')
subRes = 5.0 - MovingAverage(20, 'close')
concated = sumTotal - (ma20 ^ sumTotal)
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma20.push(data)
sumTotal.push(data)
subRes.push(data)
concated.push(data)
expected = 5.0 - ma20.result()
calculated = subRes.result()
self.assertAlmostEqual(
calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
expected = (sumTotal.result() - ma20.result(), 0.0)
calculated = concated.result()
self.assertAlmostEqual(
calculated[0], expected[0], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[0], calculated[0]))
self.assertAlmostEqual(
calculated[1], expected[1], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[1], calculated[1]))
def testCompoundedOperator(self):
ma5 = MovingAverage(5, 'x')
maxer = Max('close')
max5ma = Max('close') >> MovingAverage(5, 'max')
max5ma2 = MovingAverage(5, Max('close'))
for i, close in enumerate(self.sampleClose):
data = {'close': close, 'open': 1.}
maxer.push(data)
data2 = {'x': maxer.result()}
ma5.push(data2)
max5ma.push(data)
max5ma2.push(data)
expected = ma5.result()
calculated = max5ma.result()
self.assertAlmostEqual(
calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
calculated = max5ma2.result()
self.assertAlmostEqual(
calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
with self.assertRaises(ValueError):
_ = Max('close') >> math.sqrt
def testSubOperator(self):
ma5 = MovingAverage(5, 'close')
sumTotal = Sum('open')
subRes = MovingAverage(5, 'close') - Sum('open')
concated = (MovingAverage(5, 'close') ^ Sum('open')) - Sum('open')
for i, (open,
close) in enumerate(zip(self.sampleOpen, self.sampleClose)):
data = {'close': close, 'open': open}
ma5.push(data)
sumTotal.push(data)
subRes.push(data)
concated.push(data)
expected = ma5.result() - sumTotal.result()
calculated = subRes.result()
self.assertAlmostEqual(
calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
expected = (ma5.result() - sumTotal.result(), 0.0)
calculated = concated.result()
self.assertAlmostEqual(
calculated[0], expected[0], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[0], calculated[0]))
self.assertAlmostEqual(
calculated[1], expected[1], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[1], calculated[1]))
class MovingAlphaBeta(StatefulValueHolder):
def __init__(self, window, dependency=('pRet', 'mRet', 'riskFree')):
self._returnSize = 2
super(MovingAlphaBeta, self).__init__(window, dependency)
self._pReturnMean = MovingAverage(window, dependency='x')
self._mReturnMean = MovingAverage(window, dependency='y')
self._pReturnVar = MovingVariance(window, dependency='x')
self._mReturnVar = MovingVariance(window, dependency='y')
self._correlationHolder = MovingCorrelation(window, dependency=['x', 'y'])
def push(self, data):
value = super(MovingAlphaBeta, self).push(data)
if value is None:
return
pReturn = value[0]
mReturn = value[1]
rf = value[2]
data = {'x': pReturn - rf, 'y': mReturn - rf}
self._pReturnMean.push(data)
self._mReturnMean.push(data)
self._pReturnVar.push(data)
self._mReturnVar.push(data)
self._correlationHolder.push(data)
def result(self):
corr = self._correlationHolder.result()
pStd = math.sqrt(self._pReturnVar.result())
mStd = math.sqrt(self._mReturnVar.result())
beta = corr * pStd / mStd
alpha = self._pReturnMean.result() - beta * self._mReturnMean.result()
return alpha, beta
def testRDivOperator(self):
ma20 = MovingAverage(20, 'close')
divRes = 5.0 / MovingAverage(20, 'close')
concated = (5.0 ^ MovingAverage(20, 'close')) / MovingAverage(
20, 'close')
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma20.push(data)
divRes.push(data)
concated.push(data)
expected = 5.0 / ma20.result()
calculated = divRes.result()
self.assertAlmostEqual(
calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
expected = (5.0 / ma20.result(), 1.0)
calculated = concated.result()
self.assertAlmostEqual(
calculated[0], expected[0], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[0], calculated[0]))
self.assertAlmostEqual(
calculated[1], expected[1], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[1], calculated[1]))
def testRMultiplyOperator(self):
ma20 = MovingAverage(20, 'close')
average = Average('open')
mulRes = 5.0 * MovingAverage(20, 'close')
concated = 5.0 * (MovingAverage(20, 'close') ^ Average('open'))
for i, (open, close) in enumerate(zip(self.sampleOpen, self.sampleClose)):
data = {'close': close, 'open': open}
average.push(data)
ma20.push(data)
mulRes.push(data)
concated.push(data)
expected = 5.0 * ma20.result()
calculated = mulRes.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
expected = (5.0 * ma20.result(), 5.0 * average.result())
calculated = concated.result()
self.assertAlmostEqual(calculated[0], expected[0], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[0],
calculated[0]))
self.assertAlmostEqual(calculated[1], expected[1], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[1],
calculated[1]))
def testRSubOperator(self):
ma20 = MovingAverage(20, 'close')
sumTotal = Sum('close')
subRes = 5.0 - MovingAverage(20, 'close')
concated = sumTotal - (ma20 ^ sumTotal)
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma20.push(data)
sumTotal.push(data)
subRes.push(data)
concated.push(data)
expected = 5.0 - ma20.result()
calculated = subRes.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
expected = (sumTotal.result() - ma20.result(), 0.0)
calculated = concated.result()
self.assertAlmostEqual(calculated[0], expected[0], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[0],
calculated[0]))
self.assertAlmostEqual(calculated[1], expected[1], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[1],
calculated[1]))
def testRDivOperator(self):
ma20 = MovingAverage(20, 'close')
divRes = 5.0 / MovingAverage(20, 'close')
concated = (5.0 ^ MovingAverage(20, 'close')) / MovingAverage(20, 'close')
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma20.push(data)
divRes.push(data)
concated.push(data)
expected = 5.0 / ma20.result()
calculated = divRes.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
expected = (5.0 / ma20.result(), 1.0)
calculated = concated.result()
self.assertAlmostEqual(calculated[0], expected[0], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[0],
calculated[0]))
self.assertAlmostEqual(calculated[1], expected[1], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[1],
calculated[1]))
def testListedAndCompoundedOperator(self):
maClose = MovingAverage(20, 'close')
maOpen = MovingAverage(10, 'open')
maRf = MovingAverage(10, 'rf')
listHolder = MovingAverage(20, 'close') ^ MovingAverage(10, 'open') ^ MovingAverage(10, 'rf')
mc = MovingAlphaBeta(20, listHolder)
maCloseContainer = deque(maxlen=20)
maOpenContainer = deque(maxlen=20)
for i, (open, close, rf) in enumerate(zip(self.sampleOpen, self.sampleClose, self.sampleRf)):
data = {'close': close, 'open': open, 'rf': rf}
maClose.push(data)
maOpen.push(data)
maRf.push(data)
mc.push(data)
maCloseContainer.append(maClose.result() - maRf.result())
maOpenContainer.append(maOpen.result() - maRf.result())
if i >= 2:
expected = linregress(maOpenContainer, maCloseContainer)
calculated = mc.result()
# check alpha
self.assertAlmostEqual(expected[1], calculated[0], 10, "at index {0:d}\n"
"expected alpha: {1:f}\n"
"calculated alpha: {2:f}".format(i, expected[1],
calculated[0]))
# check beta
self.assertAlmostEqual(expected[0], calculated[1], 10, "at index {0:d}\n"
"expected beta: {1:f}\n"
"calculated beta: {2:f}".format(i, expected[0],
calculated[1]))
def testNormInvFunction(self):
ma5 = MovingAverage(5, 'close')
holder = NormInv(ma5)
sampleClose = norm.cdf(self.sampleClose)
for i, close in enumerate(sampleClose):
data = {'close': close}
ma5.push(data)
holder.push(data)
expected = norm.ppf(ma5.result())
calculated = holder.result()
self.assertAlmostEqual(calculated, expected, 6, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
holder = NormInv(ma5, fullAcc=True)
sampleClose = norm.cdf(self.sampleClose)
for i, close in enumerate(sampleClose):
data = {'close': close}
ma5.push(data)
holder.push(data)
expected = norm.ppf(ma5.result())
calculated = holder.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
def testListedAndCompoundedOperator(self):
maClose = MovingAverage(20, 'close')
maOpen = MovingAverage(10, 'open')
maRf = MovingAverage(10, 'rf')
listHolder = MovingAverage(20, 'close') ^ MovingAverage(10, 'open') ^ MovingAverage(10, 'rf')
mc = MovingAlphaBeta(20, listHolder)
maCloseContainer = deque(maxlen=20)
maOpenContainer = deque(maxlen=20)
for i, (open, close, rf) in enumerate(zip(self.sampleOpen, self.sampleClose, self.sampleRf)):
data = {'close': close, 'open': open, 'rf': rf}
maClose.push(data)
maOpen.push(data)
maRf.push(data)
mc.push(data)
maCloseContainer.append(maClose.result() - maRf.result())
maOpenContainer.append(maOpen.result() - maRf.result())
if i >= 2:
expected = linregress(maOpenContainer, maCloseContainer)
calculated = mc.result()
# check alpha
self.assertAlmostEqual(expected[1], calculated[0], 10, "at index {0:d}\n"
"expected alpha: {1:f}\n"
"calculated alpha: {2:f}".format(i, expected[1],
calculated[0]))
# check beta
self.assertAlmostEqual(expected[0], calculated[1], 10, "at index {0:d}\n"
"expected beta: {1:f}\n"
"calculated beta: {2:f}".format(i, expected[0],
calculated[1]))
class MovingAlphaBeta(StatefulValueHolder):
def __init__(self, window, dependency=('pRet', 'mRet', 'riskFree')):
self._returnSize = 2
super(MovingAlphaBeta, self).__init__(window, dependency)
self._pReturnMean = MovingAverage(window, dependency='x')
self._mReturnMean = MovingAverage(window, dependency='y')
self._pReturnVar = MovingVariance(window, dependency='x')
self._mReturnVar = MovingVariance(window, dependency='y')
self._correlationHolder = MovingCorrelation(window,
dependency=['x', 'y'])
def push(self, data):
value = super(MovingAlphaBeta, self).push(data)
if value is None:
return
pReturn = value[0]
mReturn = value[1]
rf = value[2]
data = {'x': pReturn - rf, 'y': mReturn - rf}
self._pReturnMean.push(data)
self._mReturnMean.push(data)
self._pReturnVar.push(data)
self._mReturnVar.push(data)
self._correlationHolder.push(data)
def result(self):
corr = self._correlationHolder.result()
pStd = math.sqrt(self._pReturnVar.result())
mStd = math.sqrt(self._mReturnVar.result())
beta = corr * pStd / mStd
alpha = self._pReturnMean.result() - beta * self._mReturnMean.result()
return alpha, beta
def testRMultiplyOperator(self):
ma20 = MovingAverage(20, 'close')
average = Average('open')
mulRes = 5.0 * MovingAverage(20, 'close')
concated = 5.0 * (MovingAverage(20, 'close') ^ Average('open'))
for i, (open,
close) in enumerate(zip(self.sampleOpen, self.sampleClose)):
data = {'close': close, 'open': open}
average.push(data)
ma20.push(data)
mulRes.push(data)
concated.push(data)
expected = 5.0 * ma20.result()
calculated = mulRes.result()
self.assertAlmostEqual(
calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
expected = (5.0 * ma20.result(), 5.0 * average.result())
calculated = concated.result()
self.assertAlmostEqual(
calculated[0], expected[0], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[0], calculated[0]))
self.assertAlmostEqual(
calculated[1], expected[1], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[1], calculated[1]))
def testSubOperator(self):
ma5 = MovingAverage(5, 'close')
sumTotal = Sum('open')
subRes = MovingAverage(5, 'close') - Sum('open')
concated = (MovingAverage(5, 'close') ^ Sum('open')) - Sum('open')
for i, (open, close) in enumerate(zip(self.sampleOpen, self.sampleClose)):
data = {'close': close, 'open': open}
ma5.push(data)
sumTotal.push(data)
subRes.push(data)
concated.push(data)
expected = ma5.result() - sumTotal.result()
calculated = subRes.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
expected = (ma5.result() - sumTotal.result(), 0.0)
calculated = concated.result()
self.assertAlmostEqual(calculated[0], expected[0], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[0],
calculated[0]))
self.assertAlmostEqual(calculated[1], expected[1], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[1],
calculated[1]))
def testCompoundedOperator(self):
ma5 = MovingAverage(5, 'x')
maxer = Max('close')
max5ma = Max('close') >> MovingAverage(5)
max5ma2 = MovingAverage(5, Max('close'))
average = Average('close')
sumM = Sum('close')
mvTest = Correlation(dependency=('x', 'y'))
mvCorr = (Average('close')
^ Sum('close')) >> Correlation(dependency=('x', 'y'))
for i, close in enumerate(self.sampleClose):
data = {'close': close, 'open': 1.}
maxer.push(data)
data2 = {'x': maxer.result()}
ma5.push(data2)
max5ma.push(data)
max5ma2.push(data)
average.push(data)
sumM.push(data)
data3 = {'x': average.result(), 'y': sumM.result()}
mvTest.push(data3)
mvCorr.push(data)
expected = ma5.result()
calculated = max5ma.result()
self.assertAlmostEqual(
calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
calculated = max5ma2.result()
self.assertAlmostEqual(
calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
if i >= 1:
expected = mvTest.result()
calculated = mvCorr.result()
self.assertAlmostEqual(
calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
with self.assertRaises(ValueError):
_ = Max('close') >> math.sqrt
with self.assertRaises(ValueError):
_ = (Max('close') ^ Min('close')) >> MovingCorrelation(
20, dependency=('x', 'y', 'z'))
(Max('close') ^ Min('close')) >> MovingCorrelation(
20, dependency=('x', 'y'))
def testCompoundedOperator(self):
ma5 = MovingAverage(5, 'x')
maxer = Max('close')
max5ma = Max('close') >> MovingAverage(5)
max5ma2 = MovingAverage(5, Max('close'))
average = Average('close')
sumM = Sum('close')
mvTest = Correlation(dependency=('x', 'y'))
mvCorr = (Average('close') ^ Sum('close')) >> Correlation(dependency=('x', 'y'))
for i, close in enumerate(self.sampleClose):
data = {'close': close, 'open': open}
maxer.push(data)
data2 = {'x': maxer.result()}
ma5.push(data2)
max5ma.push(data)
max5ma2.push(data)
average.push(data)
sumM.push(data)
data3 = {'x': average.result(), 'y': sumM.result()}
mvTest.push(data3)
mvCorr.push(data)
expected = ma5.result()
calculated = max5ma.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
calculated = max5ma2.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
if i >= 1:
expected = mvTest.result()
calculated = mvCorr.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
with self.assertRaises(ValueError):
_ = Max('close') >> math.sqrt
with self.assertRaises(ValueError):
_ = (Max('close') ^ Minimum('close')) >> MovingCorrelation(20, dependency=('x', 'y', 'z'))
(Max('close') ^ Minimum('close')) >> MovingCorrelation(20, dependency=('x', 'y'))
def testPlusOperator(self):
ma5 = MovingAverage(5, 'close')
ma20 = MovingAverage(20, 'open')
plusRes = ma5 + ma20
for i, (open, close) in enumerate(zip(self.sampleOpen, self.sampleClose)):
data = {'close': close, 'open': open}
ma5.push(data)
ma20.push(data)
plusRes.push(data)
expected = ma5.result() + ma20.result()
calculated = plusRes.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
def testSignFunction(self):
ma5 = MovingAverage(5, 'close')
holder = Sign(ma5)
holder2 = (ma5 ^ (-ma5)) >> Sign
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma5.push(data)
holder.push(data)
holder2.push(data)
expected = 1 if ma5.result() >= 0 else -1
calculated = holder.result()
self.assertEqual(calculated, expected, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
calculated = holder2.result()
self.assertEqual(calculated[0], expected, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated[0]))
self.assertEqual(calculated[1], -expected, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated[1]))
def testSignFunction(self):
ma5 = MovingAverage(5, 'close')
holder = Sign(ma5)
holder2 = (ma5 ^ (-ma5)) >> Sign
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma5.push(data)
holder.push(data)
holder2.push(data)
expected = 1 if ma5.result() >= 0 else -1
calculated = holder.result()
self.assertEqual(
calculated, expected, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
calculated = holder2.result()
self.assertEqual(
calculated[0], expected, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated[0]))
self.assertEqual(
calculated[1], -expected, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated[1]))
def testLogFunction(self):
ma5 = MovingAverage(5, 'close')
holder = Log(ma5)
holder2 = (ma5 ^ ma5) >> Log
sampleClose = np.exp(self.sampleClose)
for i, close in enumerate(sampleClose):
data = {'close': close}
ma5.push(data)
holder.push(data)
holder2.push(data)
expected = math.log(ma5.result())
calculated = holder.result()
self.assertAlmostEqual(
calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
calculated = holder2.result()
for cal in calculated:
self.assertAlmostEqual(
cal, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, cal))
def testRPlusOperator(self):
ma5 = MovingAverage(5, 'close')
ma20 = MovingAverage(20, 'close')
plusRes = 5.0 + MovingAverage(20, 'close')
concated = 2.0 + (ma5 ^ ma20)
concated2 = ma5 + ma20
concated3 = (ma5 ^ ma20) + ma5
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma5.push(data)
ma20.push(data)
plusRes.push(data)
concated.push(data)
concated2.push(data)
concated3.push(data)
expected = 5.0 + ma20.result()
calculated = plusRes.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
expected = (ma5.result() + 2.0, ma20.result() + 2.0)
calculated = concated.result()
self.assertAlmostEqual(calculated[0], expected[0], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[0],
calculated[0]))
self.assertAlmostEqual(calculated[1], expected[1], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[1],
calculated[1]))
expected = ma5.result() + ma20.result()
calculated = concated2.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
expected = (ma5.result() + ma5.result(), ma5.result() + ma20.result())
calculated = concated3.result()
self.assertAlmostEqual(calculated[0], expected[0], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[0],
calculated[0]))
self.assertAlmostEqual(calculated[1], expected[1], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[1],
calculated[1]))
def testMultipleOperators(self):
ma20 = MovingAverage(20, 'close')
ma120 = MovingAverage(120, 'close')
mmax = MovingMax(50, 'open')
res = (MovingAverage(20, 'close') - MovingAverage(120, 'close')) / MovingMax(50, 'open')
for i, (open, close) in enumerate(zip(self.sampleOpen, self.sampleClose)):
data = {'close': close, 'open': open}
ma20.push(data)
ma120.push(data)
mmax.push(data)
res.push(data)
expected = (ma20.result() - ma120.result()) / mmax.result()
calculated = res.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
def testMultipleOperators(self):
ma20 = MovingAverage(20, 'close')
ma120 = MovingAverage(120, 'close')
mmax = MovingMax(50, 'open')
res = (MovingAverage(20, 'close') - MovingAverage(120, 'close')) / MovingMax(50, 'open')
for i, (open, close) in enumerate(zip(self.sampleOpen, self.sampleClose)):
data = {'close': close, 'open': open}
ma20.push(data)
ma120.push(data)
mmax.push(data)
res.push(data)
expected = (ma20.result() - ma120.result()) / mmax.result()
calculated = res.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
def testRPlusOperator(self):
ma5 = MovingAverage(5, 'close')
ma20 = MovingAverage(20, 'close')
plusRes = 5.0 + MovingAverage(20, 'close')
concated = 2.0 + (ma5 ^ ma20)
concated2 = ma5 + ma20
concated3 = (ma5 ^ ma20) + ma5
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma5.push(data)
ma20.push(data)
plusRes.push(data)
concated.push(data)
concated2.push(data)
concated3.push(data)
expected = 5.0 + ma20.result()
calculated = plusRes.result()
self.assertAlmostEqual(
calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
expected = (ma5.result() + 2.0, ma20.result() + 2.0)
calculated = concated.result()
self.assertAlmostEqual(
calculated[0], expected[0], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[0], calculated[0]))
self.assertAlmostEqual(
calculated[1], expected[1], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[1], calculated[1]))
expected = ma5.result() + ma20.result()
calculated = concated2.result()
self.assertAlmostEqual(
calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
expected = (ma5.result() + ma5.result(),
ma5.result() + ma20.result())
calculated = concated3.result()
self.assertAlmostEqual(
calculated[0], expected[0], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[0], calculated[0]))
self.assertAlmostEqual(
calculated[1], expected[1], 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected[1], calculated[1]))
class MovingAlphaBeta(StatefulValueHolder):
def __init__(self, window, dependency=('pRet', 'mRet', 'riskFree')):
super(MovingAlphaBeta, self).__init__(window, dependency)
self._returnSize = 2
self._pReturnMean = MovingAverage(window, dependency='x')
self._mReturnMean = MovingAverage(window, dependency='y')
self._pReturnVar = MovingVariance(window, dependency='x')
self._mReturnVar = MovingVariance(window, dependency='y')
self._correlationHolder = MovingCorrelation(window, dependency=['x', 'y'])
def push(self, data):
value = super(MovingAlphaBeta, self).push(data)
if np.any(np.isnan(value)):
return np.nan
pReturn = value[0]
mReturn = value[1]
rf = value[2]
data = {'x': pReturn - rf, 'y': mReturn - rf}
self._pReturnMean.push(data)
self._mReturnMean.push(data)
self._pReturnVar.push(data)
self._mReturnVar.push(data)
self._correlationHolder.push(data)
def result(self):
corr = self._correlationHolder.result()
tmp = self._pReturnVar.result()
if not isClose(tmp, 0.):
pStd = math.sqrt(tmp)
else:
pStd = 0.
tmp = self._mReturnVar.result()
if not isClose(tmp, 0.):
mStd = math.sqrt(tmp)
else:
mStd = 0.
if not isClose(tmp, 0.):
beta = corr * pStd / mStd
else:
beta = 0.
alpha = self._pReturnMean.result() - beta * self._mReturnMean.result()
return alpha, beta
class MovingAverageDrawdown(StatefulValueHolder):
def __init__(self, window, dependency='ret'):
super(MovingAverageDrawdown, self).__init__(window, dependency)
self._returnSize = 2
self._drawdownCalculator = MovingDrawDown(window, dependency='ret')
self._drawdownMean = MovingAverage(window, dependency='drawdown')
self._durationMean = MovingAverage(window, dependency='duration')
def push(self, data):
value = super(MovingAverageDrawdown, self).push(data)
if value is None:
return
self._drawdownCalculator.push(dict(ret=value))
drawdown, duration, _ = self._drawdownCalculator.result()
self._drawdownMean.push(dict(drawdown=drawdown))
self._durationMean.push(dict(duration=duration))
def result(self):
return self._drawdownMean.result(), self._durationMean.result()
class MovingAverageDrawdown(StatefulValueHolder):
def __init__(self, window, dependency='ret'):
super(MovingAverageDrawdown, self).__init__(window, dependency)
self._returnSize = 2
self._drawdownCalculator = MovingDrawDown(window, dependency='ret')
self._drawdownMean = MovingAverage(window, dependency='drawdown')
self._durationMean = MovingAverage(window, dependency='duration')
def push(self, data):
value = super(MovingAverageDrawdown, self).push(data)
if value is None:
return
self._drawdownCalculator.push(dict(ret=value))
drawdown, duration, _ = self._drawdownCalculator.result()
self._drawdownMean.push(dict(drawdown=drawdown))
self._durationMean.push(dict(duration=duration))
def result(self):
return self._drawdownMean.result(), self._durationMean.result()
def testListedOperator(self):
ma20 = MovingAverage(20, 'close')
maxer = Max('open')
minimumer = Minimum('close')
listHolder = MovingAverage(20,
'close') ^ Max('open') ^ Minimum('close')
listHolder2 = 2.0 ^ MovingAverage(20, 'close')
listHolder3 = MovingAverage(20, 'close') ^ 2.0
for i, (open,
close) in enumerate(zip(self.sampleOpen, self.sampleClose)):
data = {'close': close, 'open': open}
ma20.push(data)
maxer.push(data)
minimumer.push(data)
listHolder.push(data)
listHolder2.push(data)
listHolder3.push(data)
expected = (ma20.result(), maxer.result(), minimumer.result())
calculated = listHolder.result()
for ev, cv in zip(expected, calculated):
self.assertAlmostEqual(
ev, cv, 12, "at index {0:d}\n"
"expected: {1}\n"
"calculated: {2}".format(i, expected, calculated))
expected = (2.0, ma20.result())
calculated = listHolder2.result()
for ev, cv in zip(expected, calculated):
self.assertAlmostEqual(
ev, cv, 12, "at index {0:d}\n"
"expected: {1}\n"
"calculated: {2}".format(i, expected, calculated))
expected = (ma20.result(), 2.0)
calculated = listHolder3.result()
for ev, cv in zip(expected, calculated):
self.assertAlmostEqual(
ev, cv, 12, "at index {0:d}\n"
"expected: {1}\n"
"calculated: {2}".format(i, expected, calculated))
def testExpFunction(self):
ma5 = MovingAverage(5, 'close')
holder = Exp(MovingAverage(5, 'close'))
holder2 = MovingAverage(5, 'close') >> Exp
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma5.push(data)
holder.push(data)
holder2.push(data)
expected = math.exp(ma5.result())
calculated = holder.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
calculated = holder2.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
def testExpFunction(self):
ma5 = MovingAverage(5, 'close')
holder = Exp(MovingAverage(5, 'close'))
holder2 = MovingAverage(5, 'close') >> Exp
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma5.push(data)
holder.push(data)
holder2.push(data)
expected = math.exp(ma5.result())
calculated = holder.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
calculated = holder2.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
def testNegativeOperator(self):
ma20 = MovingAverage(20, 'close')
negma20 = -ma20
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma20.push(data)
negma20.push(data)
expected = -ma20.result()
calculated = negma20.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
def testPowFunction(self):
ma5min = MovingAverage(5, 'close') >> Minimum
holder = Pow(ma5min, 3)
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma5min.push(data)
holder.push(data)
expected = math.pow(ma5min.result(), 3)
calculated = holder.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
def testListedOperator(self):
ma20 = MovingAverage(20, 'close')
maxer = Max('open')
minimumer = Minimum('close')
listHolder = MovingAverage(20, 'close') ^ Max('open') ^ Minimum('close')
listHolder2 = 2.0 ^ MovingAverage(20, 'close')
listHolder3 = MovingAverage(20, 'close') ^ 2.0
for i, (open, close) in enumerate(zip(self.sampleOpen, self.sampleClose)):
data = {'close': close, 'open': open}
ma20.push(data)
maxer.push(data)
minimumer.push(data)
listHolder.push(data)
listHolder2.push(data)
listHolder3.push(data)
expected = (ma20.result(), maxer.result(), minimumer.result())
calculated = listHolder.result()
for ev, cv in zip(expected, calculated):
self.assertAlmostEqual(ev, cv, 12, "at index {0:d}\n"
"expected: {1}\n"
"calculated: {2}".format(i, expected, calculated))
expected = (2.0, ma20.result())
calculated = listHolder2.result()
for ev, cv in zip(expected, calculated):
self.assertAlmostEqual(ev, cv, 12, "at index {0:d}\n"
"expected: {1}\n"
"calculated: {2}".format(i, expected, calculated))
expected = (ma20.result(), 2.0)
calculated = listHolder3.result()
for ev, cv in zip(expected, calculated):
self.assertAlmostEqual(ev, cv, 12, "at index {0:d}\n"
"expected: {1}\n"
"calculated: {2}".format(i, expected, calculated))
def testRPlusOperator(self):
ma5 = MovingAverage(5, 'close')
ma20 = MovingAverage(20, 'close')
plusRes = 5.0 + MovingAverage(20, 'close')
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma5.push(data)
ma20.push(data)
plusRes.push(data)
expected = 5.0 + ma20.result()
calculated = plusRes.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
class MovingSharp(StatefulValueHolder):
def __init__(self, window, dependency=('ret', 'riskFree')):
super(MovingSharp, self).__init__(window, dependency)
self._mean = MovingAverage(window, dependency='x')
self._var = MovingVariance(window, dependency='x', isPopulation=False)
def push(self, data):
value = super(MovingSharp, self).push(data)
ret = value[0]
benchmark = value[1]
data = {'x': ret - benchmark}
self._mean.push(data)
self._var.push(data)
def result(self):
return self._mean.result() / math.sqrt(self._var.result())
class MovingSharp(StatefulValueHolder):
def __init__(self, window, dependency=('ret', 'riskFree')):
super(MovingSharp, self).__init__(window, dependency)
self._mean = MovingAverage(window, dependency='x')
self._var = MovingVariance(window, dependency='x', isPopulation=False)
def push(self, data):
value = super(MovingSharp, self).push(data)
ret = value[0]
benchmark = value[1]
data = {'x': ret - benchmark}
self._mean.push(data)
self._var.push(data)
def result(self):
return self._mean.result() / math.sqrt(self._var.result())
class MovingSortino(StatefulValueHolder):
def __init__(self, window, dependency=('ret', 'riskFree')):
super(MovingSortino, self).__init__(window, dependency)
self._mean = MovingAverage(window, dependency='x')
self._negativeVar = MovingNegativeVariance(window, dependency='x')
def push(self, data):
value = super(MovingSortino, self).push(data)
if value is None:
return
ret = value[0]
benchmark = value[1]
data = {'x': ret - benchmark}
self._mean.push(data)
self._negativeVar.push(data)
def result(self):
return self._mean.result() / math.sqrt(self._negativeVar.result())
class MovingSortino(StatefulValueHolder):
def __init__(self, window, dependency=('ret', 'riskFree')):
super(MovingSortino, self).__init__(window, dependency)
self._mean = MovingAverage(window, dependency='x')
self._negativeVar = MovingNegativeVariance(window, dependency='x')
def push(self, data):
value = super(MovingSortino, self).push(data)
if value is None:
return
ret = value[0]
benchmark = value[1]
data = {'x': ret - benchmark}
self._mean.push(data)
self._negativeVar.push(data)
def result(self):
return self._mean.result() / math.sqrt(self._negativeVar.result())
def testNegativeOperator(self):
ma20 = MovingAverage(20, 'close')
negma20 = -ma20
negma20square = -(ma20 ^ ma20)
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma20.push(data)
negma20.push(data)
negma20square.push(data)
expected = -ma20.result()
calculated = negma20.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
calculated = negma20square.result()
for cal in calculated:
self.assertAlmostEqual(cal, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, cal))
def testPowFunction(self):
ma5min = MovingAverage(5, 'close') >> Minimum
holder = Pow(ma5min, 3)
holder2 = Pow(ma5min ^ ma5min, 3)
for i, close in enumerate(self.sampleClose):
data = {'close': close}
ma5min.push(data)
holder.push(data)
holder2.push(data)
expected = math.pow(ma5min.result(), 3)
calculated = holder.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
calculated = holder2.result()
for cal in calculated:
self.assertAlmostEqual(cal, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, cal))
def testLogFunction(self):
ma5 = MovingAverage(5, 'close')
holder = Log(ma5)
holder2 = (ma5 ^ ma5) >> Log
sampleClose = np.exp(self.sampleClose)
for i, close in enumerate(sampleClose):
data = {'close': close}
ma5.push(data)
holder.push(data)
holder2.push(data)
expected = math.log(ma5.result())
calculated = holder.result()
self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, calculated))
calculated = holder2.result()
for cal in calculated:
self.assertAlmostEqual(cal, expected, 12, "at index {0:d}\n"
"expected: {1:f}\n"
"calculated: {2:f}".format(i, expected, cal))
