def testSecurityValuesRes(self):
data1 = np.array([3, 2, 2., 1., 4., 5.])
data2 = -np.array([3, 2, 2., 1., 4., 5.])
index = [1, 2, 3, 4, 5, 6]
test1 = SeriesValues(data1, index)
test2 = SeriesValues(data2, index)
calculated = test1.res(test2)
expected = SeriesValues(np.zeros(len(data1)), index)
np.testing.assert_array_almost_equal(calculated.values, expected.values)
self.assertEqual(calculated.name_mapping, expected.name_mapping)
data1 = np.random.randn(100)
data2 = np.random.randn(100)
index = list(range(1, 101))
test1 = SeriesValues(data1, index)
test2 = SeriesValues(data2, index)
calculated = test1.res(test2)
expected = SeriesValues(data1 - np.dot(data2, data1) / np.dot(data2, data2) * data2, index)
np.testing.assert_array_almost_equal(calculated.values, expected.values)
self.assertEqual(calculated.name_mapping, expected.name_mapping)
def testSecurityValuesAdd(self):
data1 = np.array([3, 2, 2., 1., 4., 5.])
data2 = -np.array([3, 2, 2., 1., 4., 5.])
index = [1, 2, 3, 4, 5, 6]
test1 = SeriesValues(data1, index)
test2 = SeriesValues(data2, index)
calculated = test1 + test2
expected = SeriesValues(data1 + data2, index)
np.testing.assert_array_equal(calculated.values, expected.values)
self.assertEqual(calculated.name_mapping, expected.name_mapping)
calculated = test1 + 2.0
expected = SeriesValues(data1 + 2.0, index)
np.testing.assert_array_equal(calculated.values, expected.values)
self.assertEqual(calculated.name_mapping, expected.name_mapping)
calculated = 2.0 + test2
expected = SeriesValues(2.0 + data2, index)
np.testing.assert_array_equal(calculated.values, expected.values)
self.assertEqual(calculated.name_mapping, expected.name_mapping)
def testSecurityValuesInit(self):
data = np.array([1, 2, 3])
index = ['c', 'b', 'a']
test = SeriesValues(data, dict(zip(index, range(len(index)))))
expected = dict(zip(index, data))
for name in test.index():
self.assertEqual(test[name], expected[name])
def testSecurityValuesUnit(self):
data = np.array([3, -2, np.nan, np.nan, 4, 5])
index = [1, 2, 3, 4, 5, 6]
test = SeriesValues(data, index)
test = test.unit()
expected = SeriesValues(data / np.nansum(np.abs(data)), dict(zip(index, range(len(index)))))
for name in test.index():
if np.isnan(test[name]):
self.assertTrue(np.isnan(expected[name]))
else:
self.assertEqual(test[name], expected[name])
def testSecurityValuesRankWithGroup(self):
data = np.random.randn(3000)
groups = np.random.randint(0, 30, 3000)
index = list(range(3000))
data = SeriesValues(data, index)
groups = SeriesValues(groups, index)
test = data.rank(groups)
pd_series = pd.Series(data.values)
expected = pd_series.groupby(groups.values).rank()
np.testing.assert_array_almost_equal(test.values, expected.values)
def testSecurityValuesRank(self):
data = np.array([3, 2, np.nan, np.nan, 4, 5])
index = [1, 2, 3, 4, 5, 6]
data = SeriesValues(data, index)
test = data.rank()
expected = SeriesValues(np.array([2, 1, np.nan, np.nan, 3, 4]), dict(zip(index, range(len(index)))))
for name in test.index():
if np.isnan(test[name]):
self.assertTrue(np.isnan(expected[name]))
else:
self.assertEqual(test[name], expected[name])
def testSecurityValuesXor(self):
data1 = np.array([3, 2, 2., 1., 4., 5.])
data2 = -np.array([3, 2, 2., 1., 4., 5.])
index = [1, 2, 3, 4, 5, 6]
test1 = SeriesValues(data1, index)
test2 = SeriesValues(data2, index)
calculated = test1 ^ test2
expected = SeriesValues(np.array([data1, data2]).T, index=index)
np.testing.assert_array_equal(calculated.values, expected.values)
self.assertEqual(calculated.name_mapping, expected.name_mapping)
for name in index:
np.testing.assert_array_almost_equal(calculated[name], expected[name])
def testSecurityConstArrayValueHolder(self):
constArray = SecurityConstArrayValueHolder({'a': 1.0, 'b': 2.0})
testValue = constArray.value
expectedValue = SeriesValues(np.array([1.0, 2.0]), index=['a', 'b'])
for name in expectedValue.index():
self.assertAlmostEqual(testValue[name], expectedValue[name])
testValue = constArray.value_by_name('a')
self.assertAlmostEqual(1.0, testValue)
testValue = constArray.value_by_names(['b', 'a', 'c'])
expectedValue = SeriesValues(np.array([2.0, 1.0, np.nan]), index=['b', 'a', 'c'])
np.testing.assert_array_almost_equal(testValue.values, expectedValue.values)
self.assertEqual(testValue.name_mapping, expectedValue.name_mapping)
def testSecurityValuesDeepCopy(self):
data = np.array([3, 2, 2., 1., 4., 5.])
index = [1, 2, 3, 4, 5, 6]
test = SeriesValues(data, index)
copied = copy.deepcopy(test)
np.testing.assert_array_equal(test.values, copied.values)
self.assertEqual(test.name_mapping, copied.name_mapping)
def testShiftedSecurityValueHolder(self):
mm = SecurityMovingAverage(2, 'close')
shifted1 = mm.shift(1)
data1 = {'aapl': {'close': 1.0},
'ibm': {'close': 2.0},
'goog': {'close': 3.0}}
shifted1.push(data1)
calculated = shifted1.value
for name in calculated.index():
self.assertTrue(np.isnan(calculated[name]))
data2 = {'aapl': {'close': 2.0},
'ibm': {'close': 3.0},
'goog': {'close': 4.0}}
shifted1.push(data2)
expected = SeriesValues({'aapl': 1.0,
'ibm': 2.0,
'goog': 3.0})
calculated = shifted1.value
for name in expected.index():
self.assertAlmostEqual(expected[name], calculated[name])
data3 = ({'aapl': {'close': 3.0},
'ibm': {'close': 4.0},
'goog': {'close': 5.0}})
shifted1.push(data3)
expected = SeriesValues({'aapl': 1.5,
'ibm': 2.5,
'goog': 3.5})
calculated = shifted1.value
for name in expected.index():
self.assertAlmostEqual(expected[name], calculated[name])
def testSecurityValuesPickle(self):
data = np.array([3, 2, np.nan, np.nan, 4, 5])
index = [1, 2, 3, 4, 5, 6]
test = SeriesValues(data, index)
f = tempfile.NamedTemporaryFile('w+b', delete=False)
pickle.dump(test, f)
f.close()
with open(f.name, 'rb') as f2:
pickled = pickle.load(f2)
np.testing.assert_array_equal(test.values, pickled.values)
self.assertEqual(test.name_mapping, pickled.name_mapping)
os.unlink(f.name)
def __init__(self):
self.closes = CLOSE()
self.mul = LAST('multiplier')
self.preMul = LAST('multiplier').shift(1)
self.preCloses = CLOSE().shift(1)
self.openes = OPEN()
self.lowes = LOW()
self.highes = HIGH()
# 计算指数的备用指标
self.closeDLastClose = self.closes / self.preCloses - 1.
self.closeDOpen = self.closes / self.openes - 1.
self.closeDLow = self.closes / self.lowes - 1.
self.highDClose = 1. - self.highes / self.closes
self.ih_amount = 28
self.if_amount = 42
self.ic_amount = 12
# 定义指数的权重
names = ['000016.zicn', '000300.zicn', '000905.zicn']
self.indexWeights = SeriesValues(np.array([1., -2., 1.]),
index=dict(zip(names, range(len(names)))))
def testDeltaSecurityValueHolder(self):
mm = SecurityMovingAverage(2, 'close')
delta1 = SecurityDeltaValueHolder(mm, 2)
data1 = {'aapl': {'close': 1.0},
'ibm': {'close': 2.0},
'goog': {'close': 3.0}}
delta1.push(data1)
calculated = delta1.value
for name in calculated.index():
self.assertTrue(np.isnan(calculated[name]))
data2 = {'aapl': {'close': 2.0},
'ibm': {'close': 3.0},
'goog': {'close': 4.0}}
delta1.push(data2)
data3 = {'aapl': {'close': 3.0},
'ibm': {'close': 4.0},
'goog': {'close': 5.0}}
delta1.push(data3)
expected = SeriesValues({'aapl': 1.5,
'ibm': 1.5,
'goog': 1.5})
calculated = delta1.value
for name in expected.index():
self.assertAlmostEqual(expected[name], calculated[name])
data4 = ({'aapl': {'close': 4.0},
'ibm': {'close': 5.0},
'goog': {'close': 6.0}})
delta1.push(data4)
expected = SeriesValues({'aapl': 2.0,
'ibm': 2.0,
'goog': 2.0})
calculated = delta1.value
for name in expected.index():
self.assertAlmostEqual(expected[name], calculated[name])
def testSecuritiesValuesArithmetic(self):
benchmarkValues = {'AAPL': 1.0, 'IBM': 2.0, 'GOOG': 3.0}
values = SeriesValues(benchmarkValues)
self.assertEqual(len(benchmarkValues), len(values))
for key in benchmarkValues:
self.assertAlmostEqual(benchmarkValues[key], values[key], 12)
negValues = -values
for key in benchmarkValues:
self.assertAlmostEqual(benchmarkValues[key], -negValues[key], 12)
benchmarkValues2 = {'AAPL': 3.0, 'IBM': 2.0, 'GOOG': 1.0}
values2 = SeriesValues(benchmarkValues2)
addedValue = values + values2
for key in benchmarkValues:
self.assertAlmostEqual(benchmarkValues[key] + benchmarkValues2[key], addedValue[key], 12)
subbedValues = values - values2
for key in benchmarkValues:
self.assertAlmostEqual(benchmarkValues[key] - benchmarkValues2[key], subbedValues[key], 12)
multiValues = values * values2
for key in benchmarkValues:
self.assertAlmostEqual(benchmarkValues[key] * benchmarkValues2[key], multiValues[key], 12)
divValues = values / values2
for key in benchmarkValues:
self.assertAlmostEqual(benchmarkValues[key] / benchmarkValues2[key], divValues[key], 12)
# check operated with scalar
addedValue = values + 2.0
for key in benchmarkValues:
self.assertAlmostEqual(benchmarkValues[key] + 2.0, addedValue[key], 12)
subbedValue = values - 2.0
for key in benchmarkValues:
self.assertAlmostEqual(benchmarkValues[key] - 2.0, subbedValue[key], 12)
multiValues = values * 2.0
for key in benchmarkValues:
self.assertAlmostEqual(benchmarkValues[key] * 2.0, multiValues[key], 12)
divValues = values / 2.0
for key in benchmarkValues:
self.assertAlmostEqual(benchmarkValues[key] / 2.0, divValues[key], 12)
# check right associate operators
addedValue = 2.0 + values
for key in benchmarkValues:
self.assertAlmostEqual(2.0 + benchmarkValues[key], addedValue[key], 12)
subbedValue = 2.0 - values
for key in benchmarkValues:
self.assertAlmostEqual(2.0 - benchmarkValues[key], subbedValue[key], 12)
multiValues = 2.0 * values
for key in benchmarkValues:
self.assertAlmostEqual(2.0 * benchmarkValues[key], multiValues[key], 12)
divValues = 2.0 / values
for key in benchmarkValues:
self.assertAlmostEqual(2.0 / benchmarkValues[key], divValues[key], 12)
def testSecuritiesValuesComparison(self):
benchmarkValues = SeriesValues({'AAPL': 1.0, 'IBM': 2.0, 'GOOG': 3.0})
calculated = benchmarkValues > 1.5
expected = SeriesValues({'AAPL': False, 'IBM': True, 'GOOG': True})
self.checker(expected, calculated)
calculated = benchmarkValues < 1.5
expected = SeriesValues({'AAPL': True, 'IBM': False, 'GOOG': False})
self.checker(expected, calculated)
calculated = benchmarkValues >= 1.0
expected = SeriesValues({'AAPL': True, 'IBM': True, 'GOOG': True})
self.checker(expected, calculated)
calculated = benchmarkValues <= 2.0
expected = SeriesValues({'AAPL': True, 'IBM': True, 'GOOG': False})
self.checker(expected, calculated)
benchmarkValues = SeriesValues({'AAPL': False, 'IBM': True, 'GOOG': False})
calculated = benchmarkValues & True
expected = SeriesValues({'AAPL': False, 'IBM': True, 'GOOG': False})
self.checker(expected, calculated)
calculated = True & benchmarkValues
expected = SeriesValues({'AAPL': False, 'IBM': True, 'GOOG': False})
self.checker(expected, calculated)
calculated = benchmarkValues | True
expected = SeriesValues({'AAPL': True, 'IBM': True, 'GOOG': True})
self.checker(expected, calculated)
calculated = True | benchmarkValues
expected = SeriesValues({'AAPL': True, 'IBM': True, 'GOOG': True})
self.checker(expected, calculated)
benchmarkValues = SeriesValues({'AAPL': 1.0, 'IBM': 2.0, 'GOOG': 3.0})
calculated = benchmarkValues == 2.0
expected = SeriesValues({'AAPL': False, 'IBM': True, 'GOOG': False})
self.checker(expected, calculated)
calculated = benchmarkValues != 2.0
expected = SeriesValues({'AAPL': True, 'IBM': False, 'GOOG': True})
self.checker(expected, calculated)
