added test for moving correlation

Author: wegamekinglc

PyFin/Analysis/SecurityValueHolders.pyx

@@ -313,10 +313,10 @@ cdef class SecurityBinaryValueHolder(SecurityValueHolder):
         for name in sec_values1.index():
             try:
                 holder = self._innerHolders[name]
-                holder.push({dummy_name1: sec_values1[name], dummy_name2: sec_values2})
+                holder.push({dummy_name1: sec_values1[name], dummy_name2: sec_values2[name]})
             except KeyError:
                 holder = copy.deepcopy(self._holderTemplate)
-                holder.push({dummy_name1: sec_values1[name], dummy_name2: sec_values2})
+                holder.push({dummy_name1: sec_values1[name], dummy_name2: sec_values2[name]})
                 self._innerHolders[name] = holder
 
     def __str__(self):

PyFin/examples/demo.py

@@ -0,0 +1,35 @@
+from PyFin.api import *
+from sqlalchemy import select, create_engine, and_
+import pandas as pd
+from alphamind.data.dbmodel.models import Market
+
+engine = create_engine('postgresql+psycopg2://alpha:alpha@180.166.26.82:8889/alpha')
+begin_date = '2018-12-26'
+end_date = '2018-12-28'
+query = select([Market]).where(
+    and_(Market.trade_date >= begin_date, Market.trade_date <= end_date, ))
+mkt_df = pd.read_sql(query, engine)
+mkt_df.rename(columns={'preClosePrice': 'pre_close', 'openPrice': 'openPrice',
+                       'highestPrice': 'highestPrice', 'lowestPrice': 'lowestPrice',
+                       'closePrice': 'closePrice', 'turnoverVol': 'turnoverVol',
+                       'turnoverValue': 'turnover_value', 'accumAdjFactor': 'accum_adj',
+                       'vwap': 'vwap'}, inplace=True)
+mkt_df = mkt_df[[('000000' + str(code))[-6:][0] in '036' for code in mkt_df['code']]]
+trade_date_list = list(set(mkt_df.trade_date))
+trade_date_list.sort(reverse=True)
+mkt_df = mkt_df.sort_values(['trade_date', 'code']).set_index(['trade_date', 'code'])
+mkt_df = mkt_df[mkt_df['turnoverVol'] > 0]
+
+import datetime as dt
+
+start = dt.datetime.now()
+
+expression1 = LAST('closePrice') * 2 - LAST('lowestPrice') - LAST('highestPrice')
+expression2 = LAST('highestPrice') - LAST('lowestPrice')
+
+alpha2 = DIFF(expression1 / expression2) * - 1
+
+df = mkt_df.loc['2018-12-26':'2018-12-28'].reset_index(level=1)
+df['alpha2'] = alpha2.transform(df, name='alpha2', category_field='code')['alpha2']
+#df[['trade_date', 'code', 'closePrice', 'highestPrice', 'lowestPrice', 'alpha2']].set_index('code').loc[603999]
+print("elapsed time: {0}".format(dt.datetime.now() - start))

PyFin/examples/demo2.py

@@ -0,0 +1,8 @@
+from PyFin.Analysis.TechnicalAnalysis import SecurityMovingRank
+from PyFin.Math.Accumulators.StatefulAccumulators import MovingCorrelation
+# TSRANK(VOLUME,5)
+expression1 = SecurityMovingRank(5, 'turnoverVol')
+# TSRANK(HIGH,5)
+expression2 = SecurityMovingRank(5, 'highPrice')
+
+MovingCorrelation(5, expression1, expression2)

PyFin/tests/Analysis/TechnicalAnalysis/testStatefulTechnicalAnalysers.py

@@ -395,6 +395,34 @@ def testSecurityMovingRank(self):
                                                                  'expected:   {1:.12f}\n'
                                                                  'calculated: {2:.12f}'.format(i, expected, calculated))
 
+    def testSecurityMovingCorrelation(self):
+        window = 120
+        mc = SecurityMovingCorrelation(window, ['close'], ['open'])
+
+        for i in range(len(self.aapl['close'])):
+            data = dict(aapl=dict(close=self.aapl['close'][i],
+                                  open=self.aapl['open'][i]),
+                        ibm=dict(close=self.ibm['close'][i],
+                                 open=self.ibm['open'][i]))
+            mc.push(data)
+            if i < window:
+                start = 0
+            else:
+                start = i + 1 - window
+
+            if i < 1:
+                continue
+
+            value = mc.value
+            for name in value.index():
+                xs = self.dataSet[name]['close'][start:(i + 1)]
+                ys = self.dataSet[name]['open'][start:(i + 1)]
+                expected = np.corrcoef(xs, ys)[0, 1]
+                calculated = value[name]
+                self.assertAlmostEqual(expected, calculated, 12, 'at index {0}\n'
+                                                                 'expected:   {1:.12f}\n'
+                                                                 'calculated: {2:.12f}'.format(i, expected, calculated))
+
     def testSecurityMovingQuantile(self):
         window = 10
         mq = SecurityMovingQuantile(window, ['close'])