├── [deprecated] tdx_dayline_read_seek_end.py ├── [deprecated]tdx_test_parsedate.py ├── __backup_watterson_frame.py ├── _reg.py ├── afunc.py ├── afunc_console.py ├── climb_func_findbest.py ├── climb_max_earn.py ├── freegraph.py ├── jieduan_gereate_txt.py ├── libqda_struct.py ├── tdx2.py ├── tdx_memcache.py ├── tdx_mice6208.py ├── test_cat6208_4daymax.py ├── test_listctrl.py ├── test_thread.py ├── test_urllib_thread.py ├── util_static.py ├── watt_ex_a.py ├── watterson_analysis.py ├── watterson_analysis_echo.py ├── watterson_detector.py ├── watterson_frame.py ├── watterson_lib.py ├── watterson_list_disp.py └── watterson_test.py /[deprecated] tdx_dayline_read_seek_end.py: -------------------------------------------------------------------------------- 1 | import struct 2 | import os 3 | 4 | str_tdx_dayline_format = "iiiiifii" 5 | size_of_tdx_dayline = 32 6 | 7 | f = open("C:\\new_tdx\\vipdoc\\sh\\lday\\sh000001.day", 'rb') 8 | 9 | f.seek(-32*100, os.SEEK_END) 10 | print f.tell() 11 | 12 | for i in range(0,100): 13 | rd = f.read(32) 14 | if not rd: break 15 | print i, len(rd) 16 | st = struct.unpack(str_tdx_dayline_format, rd) 17 | print st 18 | 19 | f.close() 20 | 21 | raw_input() -------------------------------------------------------------------------------- /[deprecated]tdx_test_parsedate.py: -------------------------------------------------------------------------------- 1 | import tdx2 2 | 3 | dline = tdx2.get_dayline_by_fid() 4 | 5 | strDateRange = str(tdx2.parse_time_reverse( dline[0].ftime )) + '-' + \ 6 | str(tdx2.parse_time_reverse( dline[-1].ftime )) 7 | 8 | print strDateRange -------------------------------------------------------------------------------- /__backup_watterson_frame.py: -------------------------------------------------------------------------------- 1 | 2 | import wx 3 | import random 4 | import watterson_lib 5 | import tdx2 6 | import afunc 7 | import watterson_analysis 8 | from numpy import * 9 | 10 | import pickle 11 | 12 | def arr_save_to_file(arr, filename): 13 | outputfile = open(filename, 'wb') 14 | pickle.dump(arr, outputfile, -1) 15 | outputfile.close() 16 | 17 | def load_arr_from_file(filename): 18 | outputfile = open(filename, 'rb') 19 | arr = pickle.load(outputfile) 20 | outputfile.close() 21 | return arr 22 | 23 | wordlist = [] 24 | 25 | INIT_POW = [100,200,300] 26 | MAX_LOAD_ITEM = 3000 27 | FILTER1 = 1 # filename head excepting: sh0 sh1 sh2 sh5 sh8 28 | FILTER2 = 1 # last date is max 29 | FILTER3 = 1 # dline[-1].op < 60 30 | 31 | varlist = ['d5', 'd10','d15', 'd1', 'ma20'] 32 | varfunc = [ lambda dl: watterson_lib.delta_ratio(dl, -5), \ 33 | lambda dl: watterson_lib.delta_ratio(dl, -10), \ 34 | lambda dl: watterson_lib.delta_ratio(dl, -15), \ 35 | lambda dl: watterson_lib.delta_ratio(dl, -1), \ 36 | lambda dl: float('%.2f'%afunc.average(dl, 20))] 37 | varfunc_testMode = [ lambda dl: watterson_lib.delta_ratio(dl, -5, -3), \ 38 | lambda dl: watterson_lib.delta_ratio(dl, -10,-3), \ 39 | lambda dl: watterson_lib.delta_ratio(dl, -15,-3), \ 40 | lambda dl: watterson_lib.delta_ratio(dl, -1,-3), \ 41 | lambda dl: float('%.2f'%afunc.average(dl, 20))] 42 | 43 | TESTMODE=1 44 | 45 | if TESTMODE: 46 | varfunc = varfunc_testMode 47 | 48 | def extendColumn(vName, vFunc): 49 | print 'ext' 50 | global varlist, varfunc 51 | varlist.append(vName) 52 | varfunc.append(vFunc) 53 | 54 | def strr(k): 55 | if type(k) is str: 56 | return k 57 | else: 58 | return str(k) 59 | 60 | def insertItem(lc, arr): 61 | index = lc.InsertStringItem(555, strr(arr[0])) 62 | for k in range(1, len(arr)): 63 | lc.SetStringItem(index, k, strr(arr[k])) 64 | 65 | def CalculateLv2Extend(k, pow = 0): 66 | ''' 67 | This is the KEY !!!!!! 68 | # struct of dataList[i], i=0,1,2... 69 | # (0)name(1)d5(2)d10,(3)d15,(4)d1,(5)ma20,(6)lastCL,(7)watIndex,(8)Last 70 | ''' 71 | if pow==0: pow=INIT_POW 72 | if k[5] == 0: return 0,0,0 73 | dm = (k[5] - k[6])/k[5] * pow[0] 74 | rm = -k[4]/10 * pow[1] 75 | um = (-k[1]/10/5 * 5 -k[2]/10/10 - k[3]/10/15 )* pow[2] 76 | return dm+um, '\n\md20_dec',dm, 'd1', um, 'd5,d10,d15', rm 77 | 78 | class CommonFrame(wx.Frame): 79 | def __init__(self): 80 | wx.Frame.__init__(self, None, -1, 'Watterson the Manager', 81 | size=(1900, 1000), 82 | style = wx.MINIMIZE_BOX | wx.MAXIMIZE_BOX |wx.SYSTEM_MENU | wx.CAPTION | wx.CLOSE_BOX) 83 | panel = wx.Panel(self, -1) 84 | 85 | MVW = 100 86 | MTH = 0 87 | lc = wx.ListCtrl(panel, -1, size=(1000 + MVW,900), pos=(30,20),style=wx.LC_REPORT) 88 | self.pageScroll = wx.ScrollBar(panel, -1, size = (300, 30), pos=(1060 + MVW, 20)) 89 | self.pageLabel = wx.StaticText(panel, -1, "PAGE=", size=(300,30), pos=(1060 + MVW,60)) 90 | self.sText = wx.TextCtrl(panel, -1, "", size=(600,400 + MTH), pos=(1060 + MVW, 100), style = wx.TE_MULTILINE) 91 | self.btnAnalysis = wx.Button(panel, -1, "PLOT", size=(120,40), pos = (1060+MVW, 520+MTH)) 92 | self.btnExportData = wx.Button(panel, -1, "EXPORT_FORM", size=(120,40), pos = (1200+MVW, 520+MTH)) 93 | 94 | self.btnApply = wx.Button(panel, -1, "ApplyPow", size=(120,40), pos=(1060+MVW+200, 580+MTH)) 95 | self.textPow = wx.TextCtrl(panel, -1, str(INIT_POW), size=(180, 40), pos=(1060+MVW, 580+MTH)) 96 | 97 | self.btnAnalysis.Bind(wx.EVT_BUTTON, self.OnAnalysisClick) 98 | self.btnExportData.Bind(wx.EVT_BUTTON, self.OnExportClick) 99 | self.btnApply.Bind(wx.EVT_BUTTON, self.OnApplyPowClick) 100 | 101 | self.pageScroll.SetScrollbar(0,100,1100,50) 102 | self.pageScroll.Bind(wx.EVT_SCROLL_CHANGED, self.OnScrollMove) 103 | 104 | tdx2.SetPath('Z:\\vipdoc', 'tdxpath') 105 | 106 | extendColumn('lastCL' ,lambda dline: dline[-1].cl) 107 | extendColumn('wattIndex' ,lambda dl: watterson_lib.wattIndex(dl)) 108 | extendColumn('lastTime' ,lambda dl: watterson_lib.get_last_dline_ftime(dl)) 109 | 110 | if TESTMODE: 111 | extendColumn('rd1' ,lambda dl: watterson_lib.delta_ratio(dl,-2,-1)) 112 | 113 | lc.InsertColumn(9999, "ID"); 114 | for i in varlist: 115 | lc.InsertColumn(9999, i); 116 | 117 | lc.SetColumnWidth(0, 140) 118 | lc.SetColumnWidth(lc.GetColumnCount()-2, 140) 119 | lc.SetColumnWidth(lc.GetColumnCount()-1, 140) 120 | 121 | lc.Bind(wx.EVT_LIST_COL_CLICK, self.OnColClick) 122 | lc.Bind(wx.EVT_LIST_ITEM_FOCUSED, self.OnItemClick) 123 | 124 | self.lc = lc 125 | 126 | self.powConfig = INIT_POW 127 | self.isReverse = True 128 | 129 | self.LoadFile() 130 | self.ListControlRefresh() 131 | self.Center() 132 | 133 | def OnExportClick(self, event): 134 | arr_save_to_file(self.dataList, 'temp.arr') 135 | 136 | def OnApplyPowClick(self, event): 137 | sr = self.textPow.GetValue().replace('[', '').replace(']','') 138 | sr = sr.split(',') 139 | if len(sr)<3: 140 | print 'Not Enough RR' 141 | return 142 | for k in range(len(sr)): 143 | sr[k] = float(sr[k]) 144 | self.powConfig = sr 145 | 146 | self.CalculateLv2(self.dataList) 147 | self.ListControlRefresh() 148 | 149 | def OnAnalysisClick(self, event): 150 | arr = [] 151 | for k in self.dataList: 152 | arr.append([k[7], k[9]]) 153 | arr = array(arr) 154 | watterson_analysis.showPlot(arr) 155 | def LoadFile(self): 156 | flist = tdx2.get_file_list() 157 | print 'total file count:', len(flist) 158 | flist = flist[:MAX_LOAD_ITEM] 159 | 160 | # filter 2 161 | rflist = [] 162 | for k in flist: 163 | if FILTER1: 164 | if k[:3] == "sh0": continue 165 | if k[:3] == "sh1": continue 166 | if k[:3] == "sh2": continue 167 | if k[:3] == "sh3": continue 168 | if k[:3] == "sh5": continue 169 | if k[:3] == "sh8": continue 170 | #if k[:3] == "sh5": continue 171 | rflist.append(k) 172 | 173 | flist = rflist 174 | 175 | datalist = [] 176 | dataItem = [] 177 | for k in flist: 178 | dline = tdx2.get_dayline_by_fid(k, restrictSize = 30) 179 | if FILTER3: 180 | if dline[-1].op > 60: continue 181 | if len(dline) < 30: continue 182 | print 'loading', k 183 | dataItem = [k] + [k(dline) for k in varfunc] 184 | datalist.append(dataItem) 185 | 186 | self.CalculateLv2(datalist) 187 | 188 | print 'data loading finished' 189 | self.unfilteredList = datalist 190 | def CalculateLv2(self, dataList): 191 | 192 | for k in dataList: 193 | condata = CalculateLv2Extend(k, self.powConfig) 194 | k[7] = condata[0] 195 | 196 | def OnColClick(self,event): 197 | self.pageScroll.SetThumbPosition(0) 198 | srtIndex = event.GetColumn() 199 | self.isReverse = not self.isReverse 200 | self.unfilteredList.sort(key = lambda x: x[srtIndex], reverse = self.isReverse) 201 | self.ListControlRefresh() 202 | def OnItemClick(self, event): 203 | print self.lc.GetFocusedItem() 204 | for k in self.dataList: 205 | if k[0] == self.lc.GetItemText(self.lc.GetFocusedItem()): 206 | mstr = k[0] + '\n' 207 | ls = CalculateLv2Extend(k) 208 | for u in ls: 209 | if type(u) is str: 210 | mstr += u + '\n' 211 | else: 212 | mstr += ' ' + str(u) + '\n' 213 | self.sText.SetValue(mstr) 214 | #print self.lc.getitem 215 | def ListControlRefresh(self): 216 | print 'ref' 217 | self.lc.DeleteAllItems() 218 | p=self.pageScroll.GetThumbPosition() 219 | self.pageLabel.SetLabel("PAGE=%d"%p) 220 | 221 | rlist = self.unfilteredList 222 | # filter 223 | maxd = 0 224 | for k in range(min(100,len(rlist))): maxd = max(rlist[k][8], maxd) 225 | filteredList = [] 226 | for k in rlist: 227 | if FILTER2: 228 | if k[8] != maxd: continue 229 | filteredList.append(k) 230 | for k in filteredList[p*36:36+p*36]: 231 | insertItem(self.lc, k) 232 | 233 | self.unfilteredList = rlist 234 | self.dataList = filteredList 235 | #wx.Event().GetEventObject() 236 | def OnScrollMove(self, event): 237 | print event.GetEventObject().GetThumbPosition() 238 | self.ListControlRefresh() 239 | 240 | if __name__ == '__main__': 241 | app = wx.PySimpleApp() 242 | CommonFrame().Show() 243 | app.MainLoop() -------------------------------------------------------------------------------- /_reg.py: -------------------------------------------------------------------------------- 1 | import os 2 | import sys 3 | 4 | s = 'E:\\dev\\dev_eclipse\\py_tdx_plus' 5 | sys.path.append(s) 6 | 7 | if 0: 8 | print sys.path 9 | raw_input() -------------------------------------------------------------------------------- /afunc.py: -------------------------------------------------------------------------------- 1 | import math 2 | 3 | def delta_rate(dline, dday = 0): 4 | if dday == 0: dday = len(dline) + 1 5 | t1 = (dline[-1].op - dline[-dday].op) / dline[-dday].op 6 | return t1 7 | 8 | def average(dline, dday = 0): 9 | if dday == 0: dday = len(dline) + 1 10 | sum = 0 11 | for k in dline[-dday-1:-1]: 12 | sum += k.op 13 | return sum / dday 14 | 15 | def variance(dline, dday = 0): 16 | if dday == 0: dday = len(dline) + 1 17 | average1 = average(dline, dday) 18 | for k in dline[-dday-1: -1]: 19 | sumSquare = (k.op - average1) * (k.op - average1) 20 | sumSquare = sumSquare / dday 21 | return math.sqrt(sumSquare) 22 | 23 | def delta_line(dline, dday = 0): 24 | if dday==0: dday = len(dline) + 1 25 | deltaline = [] 26 | for k in range(-dday, -2): 27 | deltaline.append(dline[k] / dline[k+1]) 28 | deltaline.append(1) 29 | return deltaline -------------------------------------------------------------------------------- /afunc_console.py: -------------------------------------------------------------------------------- 1 | """ 2 | examples: 3 | date 5000 4 | daterev 20100503 5 | """ 6 | 7 | import tdx2 8 | 9 | def func1(a): 10 | print tdx2.parse_time_reverse( int(a[4:]) ) 11 | 12 | def func2(a): 13 | print tdx2.parse_time(a[4:].strip()) 14 | 15 | print 'input h for help, q for quit' 16 | 17 | while 1: 18 | print 'afunc_console_cmd:' 19 | a = raw_input() 20 | if a[0:4] == 'date': 21 | func1(a) 22 | if a[0:7] == 'daterev': 23 | func2(a) 24 | if a=='q': 25 | print 'bye~' 26 | break 27 | if a=='h': 28 | print __doc__ -------------------------------------------------------------------------------- /climb_func_findbest.py: -------------------------------------------------------------------------------- 1 | import tdx2 2 | 3 | import random 4 | import time 5 | 6 | dlist = [] 7 | 8 | class trader: 9 | def __init__(self): 10 | # [cur, stoc] 11 | self.state_list = [10000, 0] 12 | 13 | def buy(self, dd, pric): 14 | 15 | cur, stoc = self.state_list 16 | 17 | ct = cur*dd / pric 18 | stoc += ct 19 | cur = cur * (1-dd) 20 | 21 | self.state_list = [cur, stoc] 22 | 23 | def sell(self, dd, pric): 24 | 25 | cur, stoc = self.state_list 26 | 27 | ct = stoc*dd * pric 28 | cur += ct 29 | stoc = stoc * (1-dd) 30 | 31 | self.state_list = [cur, stoc] 32 | 33 | def climb(x = 1, y = 5, z = -3, buy_co = 0.5, sell_co = 0.5): 34 | 35 | decline_degree = x 36 | exception_valve1 = y 37 | exception_valve2 = -z 38 | 39 | tr1 = trader() 40 | exc = 0 41 | 42 | r_op = dlist[0].op 43 | rr_op = dlist[0].op 44 | 45 | for k in dlist: 46 | 47 | delta_exc = -(r_op / rr_op - 1) * 100 48 | exc += delta_exc 49 | exc = exc / decline_degree 50 | 51 | if exc > exception_valve1: 52 | #exc = exception_valve1 53 | tr1.buy(buy_co, k.op) 54 | if exc < exception_valve2: 55 | tr1.sell(sell_co, k.op) 56 | 57 | rr_op = r_op 58 | r_op = k.op 59 | 60 | tr1.sell(1, k.op) 61 | 62 | return tr1.state_list[0] 63 | 64 | if __name__ == '__main__': 65 | 66 | dlist = tdx2.get_dayline_by_fid('sh000001') 67 | 68 | print 'days:', len(dlist) 69 | 70 | print 71 | print 72 | 73 | rlist = [] 74 | 75 | ''' 76 | for x in range(6,7): 77 | for y in range(-1, 0): 78 | for z in range(86,100, 1): 79 | fr = climb(1 + float(z)/10000,x,y) 80 | rlist.append([x,y,z,fr]) 81 | ''' 82 | 83 | toplist = [] 84 | for k in range(0,4): 85 | toplist.append([0,0,0,0]) 86 | currmax = 0 87 | 88 | while (1): 89 | 90 | random.seed(time.time()) 91 | rlist = [] 92 | 93 | for k in range(0,100): 94 | x = random.randint(3, 13) 95 | y = random.randint(-10,2) 96 | z = 1.0 * random.randint(0,120) 97 | br = random.randint(0,10) / 10.0 98 | sr = random.randint(0,10) / 10.0 99 | result = climb(1 + float(z)/10000,x,y, br, sr) 100 | rlist.append([result,z,x,y, br, sr]) 101 | 102 | rlist.sort(key = lambda x: x[0]) 103 | 104 | t = rlist[-1] 105 | for k in range(3,-1,-1): 106 | if t[0] > toplist[k][0]: 107 | toplist[k] = t 108 | print '__refresh_toplist' 109 | for i in toplist: 110 | print i 111 | if t == toplist[k]: break 112 | 113 | 114 | if 0: 115 | for k in rlist: 116 | print k 117 | print 'input q to quit' 118 | q = raw_input() 119 | if q == 'q': break 120 | 121 | raw_input() -------------------------------------------------------------------------------- /climb_max_earn.py: -------------------------------------------------------------------------------- 1 | import tdx2 2 | from climb_func import trader 3 | 4 | dlist = tdx2.get_dayline_by_fid('sh000001') 5 | 6 | def climb_max_earn(): 7 | 8 | tr1 = trader() 9 | 10 | r_op = dlist[0].op 11 | 12 | for k in dlist: 13 | 14 | if(k.op > r_op): 15 | tr1.buy(1, r_op) 16 | tr1.sell(1,k.op) 17 | r_op = k.op 18 | 19 | return tr1.state_list[0] 20 | 21 | print 22 | print 23 | print climb_max_earn() 24 | 25 | raw_input() -------------------------------------------------------------------------------- /freegraph.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | 5 | import wx 6 | import random 7 | import math 8 | 9 | FG_LINE = 1001 10 | FG_RECT = 1002 11 | 12 | class axisUtil(): 13 | def __init__(self): 14 | pass 15 | self.screenPixTuple = (640, 480) 16 | self.screenPixOffset = (0,0) 17 | def setScreenPixRange(self, scrTuple = (640,480)): 18 | # something like (640, 480), pixel 19 | self.screenPixTuple = scrTuple 20 | def setRealArea(self, realTuple): 21 | ''' 22 | # this is, the Area that is about to display 23 | # realTuple(xmin,ymin,xmax,ymax) 24 | # or (xmax,ymax) will keep min still in the class 25 | ''' 26 | if len(realTuple) == 2: 27 | pass 28 | else: 29 | # len==4 30 | pass 31 | pass 32 | def setScreenPixOffset(self, pixOffsetTup): 33 | self.screenPixOffset = tupFlip(pixOffsetTup) 34 | def turnToScreen(self, tup): 35 | t1 = tupPlus(tup, self.screenPixOffset) 36 | return t1 37 | def turnToReal(self, tup): 38 | pass 39 | def FlipAndCenter(self, tp4): 40 | t1 = tupFlip(tp4) 41 | t2 = tupMul(self.screenPixTuple, (.5,.5))*2 42 | t1 = tupPlus(t1, t2) 43 | return t1 44 | 45 | def tupFlip(tup1): 46 | ttup = [] 47 | for k in range(len(tup1)): 48 | ttup.append(tup1[k] * ((k%2)*-2+1)) 49 | return tuple(ttup) 50 | 51 | def tupMul(tup1, tup2): 52 | ttup = [] 53 | for k in range(len(tup1)): 54 | ttup.append(tup1[k]*tup2[k]) 55 | return tuple(ttup) 56 | 57 | def tupPlus(tup1, tup2): 58 | ttup = [] 59 | for k in range(len(tup1)): 60 | ttup.append(tup1[k]+tup2[k]) 61 | return tuple(ttup) 62 | 63 | def disGraph(dc, theGraph, offsetTuple, axisUtilInst = 0): 64 | for k in theGraph: 65 | if k[0] == 'backColor': 66 | dc.SetBackground(wx.Brush( wx.ColorRGB(k[1]) )) 67 | elif k[0] == 'foreColor': 68 | pen = wx.Pen( wx.ColorRGB( k[1] ), 1, wx.SOLID) 69 | dc.SetPen(pen) 70 | elif k[0] == 'rect': 71 | pass 72 | elif k[0] == 'line' or k[0] == FG_LINE: 73 | tpu = k[1] 74 | ut = axisUtil() 75 | ut.setScreenPixOffset( offsetTuple ) 76 | tpu = ut.turnToScreen(tpu[0:2])+ut.turnToScreen(tpu[2:4]) 77 | dc.DrawLine(*ut.FlipAndCenter(tpu)) 78 | 79 | def getFirstOffset(theGraph, axisUtilInst): 80 | for k in theGraph: 81 | if k[0] == 'line' or k[0] == FG_LINE: 82 | tp = k[1][:2] 83 | tp= axisUtilInst.turnToScreen(tp) 84 | tp = tupMul(tp, (-1, 1)) 85 | print 'first tp' ,tp 86 | return tp 87 | 88 | class PaintWindow(wx.Window): 89 | def __init__(self, parent, id, theGraph): 90 | wx.Window.__init__(self, parent, id) 91 | self.SetBackgroundColour("Black") 92 | 93 | self.lines = [] 94 | self.curGraph = [] 95 | self.pos = (0, 0) 96 | 97 | self.theGraph = theGraph 98 | self.axisUtil = axisUtil() 99 | self.offsetTuple = (0,0) 100 | self.offsetTupleOld = (0,0) 101 | 102 | self.curPosAtDown = 0 103 | self.curPosAtUp = 0 104 | 105 | self.InitBuffer() 106 | 107 | self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown) 108 | self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp) 109 | self.Bind(wx.EVT_MOTION, self.OnMotion) 110 | self.Bind(wx.EVT_SIZE, self.OnSize) 111 | self.Bind(wx.EVT_IDLE, self.OnIdle) 112 | self.Bind(wx.EVT_PAINT, self.OnPaint) 113 | 114 | def tryDraw(self): 115 | 116 | # this function is called by class 'self.usergraph' 117 | 118 | dc = wx.BufferedDC(wx.ClientDC(self), self.buffer) 119 | dc.SetBackground(wx.Brush( wx.ColorRGB(0x000000) )) 120 | dc.Clear() 121 | pen = wx.Pen( wx.ColorRGB(0xffffff), 1, wx.SOLID) 122 | dc.SetPen(pen) 123 | 124 | disGraph(dc, self.theGraph, self.offsetTuple) 125 | 126 | def InitBuffer(self): 127 | size = self.GetClientSize() 128 | self.axisUtil.setScreenPixRange(size) 129 | 130 | self.buffer = wx.EmptyBitmap(size.width, size.height) 131 | dc = wx.BufferedDC(None, self.buffer) 132 | 133 | dc.SetBackground(wx.Brush(self.GetBackgroundColour())) 134 | dc.Clear() 135 | self.reInitBuffer = False 136 | 137 | self.offsetTuple = getFirstOffset(self.theGraph, self.axisUtil) 138 | 139 | def OnLeftDown(self, event): 140 | 141 | self.curPosAtDown = event.GetPositionTuple() 142 | self.curPosAtUp = event.GetPositionTuple() 143 | self.offsetTupleOld = self.offsetTuple 144 | 145 | def OnLeftUp(self, event): 146 | 147 | self.curPosAtDown = 0 148 | print self.offsetTuple 149 | 150 | def OnMotion(self, event): 151 | 152 | if self.curPosAtDown != 0: 153 | self.offsetTuple = (self.curPosAtUp[0] - self.curPosAtDown[0] + self.offsetTupleOld[0],\ 154 | self.curPosAtUp[1] - self.curPosAtDown[1] + self.offsetTupleOld[1]) 155 | self.curPosAtUp = event.GetPositionTuple() 156 | 157 | self.tryDraw() 158 | 159 | def drawMotion(self, dc, event): 160 | 161 | newPos = event.GetPositionTuple() 162 | coords = self.pos + newPos 163 | 164 | #self.curLine.append(coords) 165 | if 1: 166 | dc.DrawLine(*coords) 167 | # format: dc.DrawLine( tuple1 ); tuple1 = (x1,y1,x2,y2) 168 | self.pos = newPos 169 | 170 | def OnSize(self, event): 171 | self.reInitBuffer = True 172 | 173 | def OnIdle(self, event): 174 | if self.reInitBuffer: 175 | self.InitBuffer() 176 | self.Refresh(False) 177 | self.reInitBuffer = False 178 | self.tryDraw() 179 | 180 | def OnPaint(self, event): 181 | dc = wx.BufferedPaintDC(self, self.buffer) 182 | 183 | class PaintFrame(wx.Frame): 184 | def __init__(self, parent, theGraph): 185 | wx.Frame.__init__(self, parent, -1, "Panit Frame", size = (1200, 800)) 186 | self.paint = PaintWindow(self, -1, theGraph) 187 | 188 | def genBigGraph(): 189 | bgra = [] 190 | pstep = 252 191 | cir = 12 192 | rad = 200 193 | stx = 100 194 | sty = 0 195 | ax = stx 196 | ay = sty 197 | for k in range(0,pstep): 198 | arc = 2*3.1415926 * cir / pstep * k 199 | x = math.cos(arc) * rad / pstep * k + stx 200 | y = math.sin(arc) * rad / pstep * k + sty 201 | qclr = int(255*float(k) / pstep) 202 | bgra.append(['foreColor',-qclr * 0x000100 + 0x00ffff]) 203 | bgra.append([FG_LINE, (x,y, ax, ay)]) 204 | ax = x 205 | ay = y 206 | return bgra 207 | 208 | def display(theGraph): 209 | app = wx.PySimpleApp() 210 | frame = PaintFrame(None, theGraph) 211 | frame.theGraph = theGraph 212 | frame.Show(True) 213 | app.MainLoop() 214 | 215 | if __name__ == '__main__': 216 | 217 | #theGraph = [['backColor',0xffffff], ['foreColor',0x0000ff],['rect', (1,1,10,10)], ['line',(20,20,30,30)]] 218 | theGraph = genBigGraph() 219 | 220 | display(theGraph) 221 | -------------------------------------------------------------------------------- /jieduan_gereate_txt.py: -------------------------------------------------------------------------------- 1 | import tdx2 2 | import afunc 3 | 4 | 5 | #tdx2.change_path("Z:\\tdxdata") 6 | 7 | def generate_stlist(flist): 8 | print "stlist gen start" 9 | stlist = [] 10 | i = 0 11 | for k in flist: 12 | # console show process percentage 13 | i+=1; 14 | if i % 100 == 0: print i, len(flist) 15 | # write function 16 | try: 17 | dline = tdx2.get_dayline_by_fid(k) 18 | delta_rate = afunc.delta_rate(dline, 3) 19 | dr = int(delta_rate * 10000) / 100.0 20 | stlist.append([k, dr]) 21 | except: 22 | pass 23 | stlist.sort(key = lambda x: -x[1]) 24 | print "stlist generated" 25 | return stlist 26 | 27 | def write_to_file(stlist): 28 | print "write to file start" 29 | ''' 30 | Write k to file 31 | k = ['sh000001', 1, 2, 3, 4, ....] 32 | infile: sh00001 \t 1 \t 2 \t3 \t 4 \t \n ... 33 | ''' 34 | f = open('period.txt', 'w') 35 | for k in stlist: 36 | f.write( k[0] + '\t') 37 | for m in k[1:]: 38 | f.write( str(m) + '\t') 39 | f.write('\n') 40 | print "write to file finished" 41 | 42 | if __name__ == '__main__': 43 | flist = tdx2.get_file_list() 44 | stlist = generate_stlist(flist) 45 | write_to_file(stlist) -------------------------------------------------------------------------------- /libqda_struct.py: -------------------------------------------------------------------------------- 1 | class fdata: 2 | def pars(self, ffid, ffname, ddaycount): 3 | self.fid = ffid; 4 | self.fname = ffname; 5 | self.daycount = ddaycount; 6 | def print_str(self): 7 | return "this data" 8 | #return " ID: " + self.fid + "\n" \ 9 | # + " NAME:" + self.fname + "\n" \ 10 | # + " DAYC:" + self.ddaycount 11 | def __init__(self): 12 | self.fid = ''; 13 | self.fname = ''; 14 | self.daycount = 0; 15 | self.fcursor = 0; 16 | 17 | class fdaydata: 18 | def pars(self, fftime, oop, hhig, llow, ccl, vvol, aamount, ddealcount): 19 | self.ftime = fftime; 20 | self.op = oop; 21 | self.hig = hhig; 22 | self.low = llow; 23 | self.cl = ccl; 24 | self.vol = vvol; 25 | self.amount = aamount; 26 | self.dealcount = ddealcount; 27 | def __init__(self): 28 | self.ftime = 0; 29 | self.op = 0.0; 30 | self.hig = 0.0; 31 | self.low = 0.0; 32 | self.cl = 0.0; 33 | self.vol = 0.0; 34 | self.amount = 0.0; 35 | self.dealcount = 0.0; 36 | def time2000(self): 37 | return self.ftime / 86400 - 10956 38 | def display(self): 39 | print "fdata display," 40 | print ' time_ ', self.ftime 41 | print ' op_' , self.op 42 | print ' last-cl_', self.cl 43 | print ' highest_', self.hig 44 | print ' lowest_ ', self.low 45 | print ' dvol_ ', self.vol 46 | print ' damount_', self.amount 47 | print ' dcount_ ', self.dealcount -------------------------------------------------------------------------------- /tdx2.py: -------------------------------------------------------------------------------- 1 | #coding: utf8 2 | 3 | execfile('E:\\dev\\dev_eclipse\\libqda\\src\\_reg.py') 4 | 5 | import struct 6 | import os 7 | import libqda_struct 8 | import time 9 | 10 | tdxpath = "C:\\new_tdx\\vipdoc" 11 | america_path = "\\ds\\lday\\" 12 | sh_path = "\\sh\\lday\\" 13 | sz_path = "\\sz\\lday\\" 14 | 15 | def change_path( pval, pname = 'tdxpath'): 16 | global tdxpath 17 | if pname == 'tdxpath': 18 | tdxpath = pval 19 | print 'tdx2.change.tdxpath =', pval 20 | # below is not used mostly 21 | if pname == 'america_path': 22 | america_path = pval 23 | if pname == 'sh_path': 24 | sh_path = pval 25 | if pname == 'sz_path': 26 | sz_path = pval 27 | 28 | SetPath = change_path 29 | 30 | def parse_time_reverse( ft): 31 | # 418x turn into 20101007 32 | s = ft 33 | s = (s + 10956) * 86400 34 | s -= 1000*60*60*6 35 | s = time.gmtime(s) 36 | s = time.strftime('%Y%m%d', s) 37 | s = int(s) 38 | return s 39 | def parse_time( ft): 40 | # 20101007 turn into 418x 41 | s = str(ft) 42 | s = time.strptime(s,'%Y%m%d') 43 | s = time.mktime(s) 44 | s += 1000*60*60*6 45 | s = s / 86400 - 10956 46 | s = int(s) 47 | return s 48 | 49 | 50 | def get_dayline_by_fid_america(str_fid = '74#AA-b', seekPoint = 0, readLength = 0): 51 | 52 | str_fid = str_fid.replace('.day','') 53 | 54 | str_tdx_dayline_format_america = "iffffiii" 55 | size_of_tdx_dayline = 32 56 | 57 | spath = tdxpath + america_path 58 | 59 | f = open(spath + str_fid + ".day", 'rb') 60 | 61 | #for i in range(0,9999): 62 | dayline = [] 63 | 64 | #skip is ok 65 | f.seek(seekPoint) 66 | 67 | rlength = 0 68 | 69 | while 1: 70 | rd = f.read(32) 71 | 72 | if not rd: break 73 | #print i, len(rd) 74 | st = struct.unpack(str_tdx_dayline_format_america, rd) 75 | #print st 76 | 77 | q = libqda_struct.fdaydata() 78 | q.pars( parse_time(st[0]), 79 | st[1],st[2],st[3],st[4], 80 | int(st[5]), 81 | int(st[6]), 82 | int(st[7]) ) 83 | 84 | dayline.append(q) 85 | 86 | rlength+=1; 87 | if rlength == readLength: break 88 | 89 | return dayline 90 | 91 | f.close() 92 | 93 | def get_dayline_by_fid(str_fid = 'sh000001', restrictSize = 0): 94 | 95 | str_fid = str_fid.replace('.day','') 96 | 97 | str_tdx_dayline_format = "iiiiifii" 98 | size_of_tdx_dayline = 32 #32 bytes per struct 99 | 100 | if str_fid[0:2] == 'sh': 101 | spath = tdxpath + sh_path 102 | else: 103 | spath = tdxpath + sz_path 104 | 105 | filename = spath + str_fid + ".day" 106 | f = open(filename, 'rb') 107 | 108 | if restrictSize != 0: 109 | fsize = os.path.getsize(filename) 110 | sr = fsize - 32 * restrictSize 111 | if sr < 0: sr = 0 112 | f.seek(sr) 113 | 114 | #for i in range(0,9999): 115 | dayline = [] 116 | while 1: 117 | rd = f.read(32) 118 | if not rd: break 119 | #print i, len(rd) 120 | st = struct.unpack(str_tdx_dayline_format, rd) 121 | #print st 122 | 123 | q = libqda_struct.fdaydata() 124 | q.pars( parse_time(st[0]), 125 | int(st[1]) / 100., 126 | int(st[2]) / 100., 127 | int(st[3]) / 100., 128 | int(st[4]) / 100., 129 | float(st[5]), 130 | int(st[6]), 131 | int(st[7]) ) 132 | 133 | dayline.append(q) 134 | 135 | return dayline 136 | 137 | f.close() 138 | 139 | 140 | 141 | def get_file_list(isAmerica = 0): 142 | 143 | print 'tdxpath is ', tdxpath 144 | 145 | listfile = [] 146 | if isAmerica: 147 | fdir = tdxpath + america_path 148 | listfile = os.listdir(fdir) 149 | return listfile 150 | else: 151 | fdir = tdxpath + sh_path 152 | listfile = os.listdir(fdir) 153 | fdir = tdxpath + sz_path 154 | listfile += os.listdir(fdir) 155 | 156 | return listfile 157 | 158 | 159 | # 读一个明码的信息表，由通达信导出 160 | def get_stock_data_list(): 161 | 162 | f = open("sh_sz_data.txt", 'r') 163 | #while 1: 164 | for m in range(0,25): 165 | rd = f.readline() 166 | if not rd: break 167 | rd = rd.split('\t') 168 | for i in range(0, len(rd)): 169 | print rd[i], 170 | print 171 | 172 | 173 | if __name__ == '__main__': 174 | if 1: 175 | print 'sh demo' 176 | dlist = get_dayline_by_fid('sh000001') 177 | print 'dlist_length:', len(dlist) 178 | dlist[0].display() 179 | dlist[-1].display() 180 | print 181 | print 182 | else: 183 | print 'america demo' 184 | dlist = get_dayline_by_fid_america() 185 | dlist[-1].display() 186 | 187 | s = get_file_list(isAmerica = 0) 188 | print s[0:5] 189 | 190 | raw_input() 191 | -------------------------------------------------------------------------------- /tdx_memcache.py: -------------------------------------------------------------------------------- 1 | #coding: utf8 2 | 3 | # 避免读取多余内容，提升速度 4 | # 建立此reader, 读取指定文件部分 5 | # 在使用RAM虚拟磁盘时效果不明显 6 | 7 | import os 8 | 9 | fpath = "C:\\new_tdx\\vipdoc\\sh\\lday" 10 | 11 | sz = os.path.getsize(fpath + '\\sh000001.day') 12 | 13 | print sz, sz / 32.0 14 | 15 | raw_input() -------------------------------------------------------------------------------- /tdx_mice6208.py: -------------------------------------------------------------------------------- 1 | #coding: utf8 2 | 3 | import tdx2 4 | import freegraph 5 | import math 6 | 7 | def list_average(dlist): 8 | if len(dlist) == 0: return 0 9 | ssum=0. 10 | for k in dlist: 11 | ssum+=k[1] 12 | return ssum/len(dlist) 13 | def list_variance(dlist): 14 | if len(dlist) == 0: return 1 15 | ssum = 0. 16 | for k in dlist: 17 | ssum += k[1]*k[1] 18 | return math.sqrt(ssum / len(dlist)) 19 | 20 | def list_vda(dlist): # variance div average 21 | if len(dlist) == 0: return 0 22 | return list_variance(dlist) / list_average(dlist) 23 | 24 | class cow6208: 25 | # 计算N日方差比均值，N在cfgTup里 26 | def __init__(self, initTup, cfgTup = (30), extTrader = 0): 27 | self.tup = initTup 28 | self.cfgTup = cfgTup 29 | self.memList = [] 30 | self.extTrader = extTrader 31 | def run(self, tup): 32 | N = self.cfgTup[0] 33 | self.memList.append(tup) 34 | if self.memList.__len__() < N: 35 | return (tup[0], 0 + self.tup[1]) 36 | else: 37 | dlist = self.memList[-N:] 38 | k = (list_vda(dlist)-1)*100000 39 | print k 40 | return (tup[0], k + self.tup[1]) 41 | 42 | 43 | class mice6208: 44 | def __init__(self, initTup, cfgTup = (1, 0.005), extTrader = 0): 45 | self.tup = initTup 46 | self.cfgTup = cfgTup 47 | self.extTrader = extTrader 48 | def run(self,tup): 49 | deltaFallT, deltaRiseT = self.cfgTup 50 | 51 | newP = self.tup[1] 52 | tarP = tup[1] 53 | ftime = tup[0] 54 | 55 | if newP < tarP: newP += (tarP - newP) * deltaRiseT 56 | elif newP > tarP: newP += (tarP - newP) * deltaFallT 57 | 58 | newTup = (ftime, newP) 59 | self.tup = newTup 60 | 61 | if self.extTrader != 0: 62 | self.extTrader.run(tup) 63 | 64 | return newTup 65 | 66 | def getExtTrader(self): 67 | return self.extTrader 68 | 69 | 70 | 71 | #theGraph = [['backColor',0xffffff], ['foreColor',0x0000ff],['rect', (1,1,10,10)], ['line',(20,20,30,30)]] 72 | 73 | def AutoCreateLine(dline, func): 74 | k = dline[0] 75 | tup = (k.ftime * zoom, k.op * zoom) 76 | #tup = (0,0) 77 | tg = [] 78 | for k in dline: 79 | tup1 = (k.ftime * zoom, k.op * zoom) 80 | tup1 = func(tup1) 81 | tg.append(['line', tup+tup1]) 82 | tup = tup1 83 | return tg 84 | 85 | dline = tdx2.get_dayline_by_fid(); 86 | zoom = 1 87 | 88 | tg = [] 89 | 90 | tg.extend(AutoCreateLine(dline, lambda x:x)) 91 | 92 | tg.append(['foreColor',0x0000ff]) 93 | 94 | k = dline[0] 95 | initTup = (k.ftime * zoom, k.op * zoom) 96 | 97 | animal = mice6208(initTup, (0.8, 0.01)) 98 | tg.extend(AutoCreateLine(dline, animal.run)) 99 | 100 | tg.append(['foreColor',0x00ffff]) 101 | 102 | animal = mice6208(initTup, (0.01, 0.8)) 103 | tg.extend(AutoCreateLine(dline, animal.run)) 104 | 105 | tg.append(['foreColor',0x800000]) 106 | 107 | #animal = cow6208(initTup, (30,)); tg.extend(AutoCreateLine(dline, animal.run)) 108 | 109 | animal = cow6208(initTup, (5,)) ; tg.extend(AutoCreateLine(dline, animal.run)) 110 | 111 | freegraph.display(tg) -------------------------------------------------------------------------------- /test_cat6208_4daymax.py: -------------------------------------------------------------------------------- 1 | #coding: utf8 2 | 3 | import tdx2 4 | import freegraph 5 | import math 6 | 7 | def list_average(dlist): 8 | if len(dlist) == 0: return 0 9 | ssum=0. 10 | for k in dlist: 11 | ssum+=k[1] 12 | return ssum/len(dlist) 13 | def list_variance(dlist): 14 | if len(dlist) == 0: return 1 15 | ssum = 0. 16 | for k in dlist: 17 | ssum += k[1]*k[1] 18 | return math.sqrt(ssum / len(dlist)) 19 | 20 | def list_vda(dlist): # variance div average 21 | if len(dlist) == 0: return 0 22 | return list_variance(dlist) / list_average(dlist) 23 | 24 | class cat6208: 25 | def __init__(self, initTup, cfgTup = (1, 0.005), extTrader = 0): 26 | self.tup = initTup 27 | self.cfgTup = cfgTup 28 | self.tt = [initTup[1]] 29 | def run(self,tup): 30 | self.tt.append(tup[1]) 31 | if len(self.tt) > 6: self.tt = self.tt[1:] 32 | newTup = tup[0], max(self.tt) 33 | return newTup 34 | 35 | def getExtTrader(self): 36 | return self.extTrader 37 | 38 | #theGraph = [['backColor',0xffffff], ['foreColor',0x0000ff],['rect', (1,1,10,10)], ['line',(20,20,30,30)]] 39 | 40 | def AutoCreateLine(dline, func): 41 | k = dline[0] 42 | tup = (k.ftime * zoom, k.op * zoom) 43 | #tup = (0,0) 44 | tg = [] 45 | for k in dline: 46 | tup1 = (k.ftime * zoom, k.op * zoom) 47 | tup1 = func(tup1) 48 | tg.append(['line', tup+tup1]) 49 | tup = tup1 50 | return tg 51 | 52 | dline = tdx2.get_dayline_by_fid(); 53 | zoom = 1 54 | 55 | tg = [] 56 | tg.append(['foreColor',0x0000ff]) 57 | 58 | tg.extend(AutoCreateLine(dline, lambda x:x)) 59 | 60 | tg.append(['foreColor',0xffffff]) 61 | 62 | k = dline[0] 63 | initTup = (k.ftime * zoom, k.op * zoom) 64 | 65 | animal = cat6208(initTup, (5,)) ; tg.extend(AutoCreateLine(dline, animal.run)) 66 | 67 | freegraph.display(tg) -------------------------------------------------------------------------------- /test_listctrl.py: -------------------------------------------------------------------------------- 1 | 2 | import wx 3 | import random 4 | 5 | wordlist = [] 6 | 7 | def strr(k): 8 | if type(k) is str: 9 | return k 10 | else: 11 | return str(k) 12 | 13 | def insertItem(lc, arr): 14 | index = lc.InsertStringItem(555, strr(arr[0])) 15 | for k in range(1, len(arr)): 16 | lc.SetStringItem(index, k, strr(arr[k])) 17 | 18 | class CommonFrame(wx.Frame): 19 | def __init__(self): 20 | wx.Frame.__init__(self, None, -1, 'commframe', 21 | size=(800, 800), 22 | style = wx.MINIMIZE_BOX |wx.SYSTEM_MENU | wx.CAPTION | wx.CLOSE_BOX) 23 | panel = wx.Panel(self, -1) 24 | lc = wx.ListCtrl(panel, -1, size=(720,720), pos=(30,20),style=wx.LC_REPORT) 25 | lc.InsertColumn(9999, "ID"); 26 | for i in range(1,12): 27 | lc.InsertColumn(9999, "VAR"+str(i)); 28 | for k in range(0,101): 29 | insertItem(lc, ("haha", k, random.randint(100,9999), 123)) 30 | self.Center() 31 | 32 | if __name__ == '__main__': 33 | app = wx.PySimpleApp() 34 | CommonFrame().Show() 35 | app.MainLoop() -------------------------------------------------------------------------------- /test_thread.py: -------------------------------------------------------------------------------- 1 | import threading 2 | import time 3 | class mythread(threading.Thread): 4 | def __init__(self,stopevt = None,File=None,name = 'subthread',Type ='event'): 5 | threading.Thread.__init__(self) 6 | self.stopevt = stopevt 7 | self.name = name 8 | self.File = File 9 | self.Type = Type 10 | 11 | 12 | def Eventrun(self): 13 | while not self.stopevt.isSet(): 14 | print self.name +' alive\n' 15 | time.sleep(2) 16 | if self.File: 17 | print 'close opened file in '+self.name+'\n' 18 | self.File.close() 19 | print self.name +' stoped\n' 20 | 21 | def Daemonrun(self): 22 | D = mythreadDaemon(self.File) 23 | D.setDaemon(True) 24 | while not self.stopevt.isSet(): 25 | print self.name +' alive\n' 26 | time.sleep(2) 27 | print self.name +' stoped\n' 28 | def run(self): 29 | if self.Type == 'event': self.Eventrun() 30 | else: self.Daemonrun() 31 | 32 | 33 | class mythreadDaemon(threading.Thread): 34 | def __init__(self,File=None,name = 'Daemonthread'): 35 | threading.Thread.__init__(self) 36 | self.name = name 37 | self.File = File 38 | def run(self): 39 | while True: 40 | print self.name +' alive\n' 41 | time.sleep(2) 42 | if self.File: 43 | print 'close opened file in '+self.name+'\n' 44 | self.File.close() 45 | print self.name +' stoped\n' 46 | 47 | def evtstop(): 48 | stopevt = threading.Event() 49 | FileA = open('testA.txt','w') 50 | FileB = open('testB.txt','w') 51 | A = mythread(stopevt,FileA,'subthreadA') 52 | B = mythread(stopevt,FileB,'subthreadB') 53 | print repr(threading.currentThread())+'alive\n' 54 | print FileA.name + ' closed? '+repr(FileA.closed)+'\n' 55 | print FileB.name + ' closed? '+repr(FileB.closed)+'\n' 56 | A.start() 57 | B.start() 58 | time.sleep(1) 59 | print repr(threading.currentThread())+'send stop signal\n' 60 | stopevt.set() 61 | A.join() 62 | B.join() 63 | print repr(threading.currentThread())+'stoped\n' 64 | print 'after A stoped, '+FileA.name + ' closed? '+repr(FileA.closed)+'\n' 65 | print 'after A stoped, '+FileB.name + ' closed? '+repr(FileB.closed)+'\n' 66 | def daemonstop(): 67 | stopevt = threading.Event() 68 | FileA = open('testA.txt','r') 69 | A = mythread(stopevt,FileA,'subthreadA',Type = 'Daemon') 70 | print repr(threading.currentThread())+'alive\n' 71 | print FileA.name + ' closed? '+repr(FileA.closed)+'\n' 72 | A.start() 73 | time.sleep(1) 74 | stopevt.set() 75 | A.join() 76 | print repr(threading.currentThread())+'stoped\n' 77 | print 'after A stoped, '+FileA.name + ' closed? '+repr(FileA.closed)+'\n' 78 | if not FileA.closed: 79 | print 'You see the differents, the resource in subthread may not released with setDaemon()' 80 | FileA.close() 81 | if __name__ =='__main__': 82 | print '-------stop subthread example with Event:----------\n' 83 | evtstop() 84 | print '-------Daemon stop subthread example :----------\n' 85 | daemonstop() -------------------------------------------------------------------------------- /test_urllib_thread.py: -------------------------------------------------------------------------------- 1 | import threading 2 | import time 3 | import urllib 4 | 5 | class timer(threading.Thread): #The timer class is derived from the class threading.Thread 6 | def __init__(self, num, interval, callback = lambda x:1): 7 | threading.Thread.__init__(self) 8 | self.thread_num = num 9 | self.interval = interval 10 | self.callback = callback 11 | self.thread_stop = False 12 | 13 | def run(self): #Overwrite run() method, put what you want the thread do here 14 | p = urllib.urlopen('http://hq.sinajs.cn/list=sh601006').read() 15 | self.callback(p) 16 | print p 17 | 18 | ''' 19 | self.stop() 20 | def stop(self): 21 | self.thread_stop = True 22 | self.callback()''' 23 | 24 | def test_urllib(): 25 | p = urllib.urlopen('http://hq.sinajs.cn/list=sh601006').read() 26 | print p 27 | 28 | def test(): 29 | thread1 = timer(1, 1) 30 | thread2 = timer(2, 2) 31 | thread1.start() 32 | thread2.start() 33 | time.sleep(10) 34 | thread1.stop() 35 | thread2.stop() 36 | return 37 | 38 | if __name__ == '__main__': 39 | #test() 40 | test_urllib() -------------------------------------------------------------------------------- /util_static.py: -------------------------------------------------------------------------------- 1 | def get_average(lst, func = lambda x: x): 2 | ssum = 0 3 | for k in lst: 4 | ssum += func(k) 5 | return ssum / float(len(lst)) 6 | 7 | def do_zoom(lst, ratio = 1.5): 8 | av = get_average(lst) 9 | for k in range(len(lst)): 10 | lst[k] = (lst[k] - av) * ratio + av 11 | return lst -------------------------------------------------------------------------------- /watt_ex_a.py: -------------------------------------------------------------------------------- 1 | # coding: utf8 2 | 3 | import pickle 4 | import matplotlib 5 | import matplotlib.pyplot as plt 6 | import numpy 7 | 8 | def arr_save_to_file(arr, filename): 9 | outputfile = open(filename, 'wb') 10 | pickle.dump(arr, outputfile, -1) 11 | outputfile.close() 12 | 13 | def load_arr_from_file(filename): 14 | outputfile = open(filename, 'rb') 15 | arr = pickle.load(outputfile) 16 | outputfile.close() 17 | return arr 18 | 19 | def showPlot(arr): 20 | x = numpy.linspace(0, 10, 1000) 21 | y = numpy.sin(x) 22 | 23 | plt.plot(x,y) 24 | plt.show() 25 | 26 | def loadArr(): 27 | arr = load_arr_from_file('temp.arr') 28 | print arr[0] 29 | list1 = [] 30 | for k in arr: 31 | list1.append([k[1],k[5],10]) 32 | list1 = numpy.array(list1) 33 | print list1 34 | #showPlot(list1) 35 | 36 | 37 | -------------------------------------------------------------------------------- /watterson_analysis.py: -------------------------------------------------------------------------------- 1 | #coding: utf8 2 | 3 | import matplotlib 4 | import matplotlib.pyplot as plt 5 | from numpy import * 6 | import watterson_analysis_echo as WAE 7 | 8 | def getFrequencyPlot(arrPl, average, wat_dta = 5, restrict_cl = (0,9999)): 9 | print arrPl.shape 10 | # define 11 | 12 | rng = (-2000,2000) 13 | st = rng[0] / wat_dta 14 | en = rng[1] / wat_dta 15 | arrlength = int(en - st) 16 | 17 | # get frequency array 18 | 19 | q = [[0,0] for k in range(arrlength)] 20 | cl_sum = [0 for k in range(arrlength)] 21 | cl_count = [0 for k in range(arrlength)] 22 | is_bigger = 0 23 | 24 | for k in arrPl: 25 | wat, dt, cl = k 26 | if cl < restrict_cl[0]: continue 27 | if cl > restrict_cl[1]: continue 28 | if dt > 19: continue # 忽略涨停 29 | 30 | ind = int((wat - rng[0])/wat_dta) 31 | q[ind][is_bigger]+=1 32 | cl_sum[ind] += dt 33 | cl_count[ind] += 1 34 | 35 | # frequency to array 36 | 37 | xArr, yArr = [], [] 38 | y2Arr = [] 39 | for k in range(len(q)): 40 | x = (k + st) * wat_dta 41 | a,b = q[k] 42 | 43 | ''' 44 | if a+b == 0: 45 | y = 0 46 | else: 47 | y = (a/float(a+b) - 0.5) * 10 48 | y += average 49 | ''' 50 | 51 | if cl_count[k] != 0: 52 | y = cl_sum[k] / float(cl_count[k]) 53 | else: 54 | y = average 55 | y2 = cl_count[k] 56 | 57 | xArr.append(x) 58 | yArr.append(y) 59 | y2Arr.append(y2) 60 | 61 | return xArr, yArr, y2Arr 62 | 63 | def getAveragePlot(arrPl): 64 | count = 0 65 | sum = 0 66 | for k in arrPl: 67 | sum += k 68 | count += 1 69 | average = sum / count 70 | return average 71 | 72 | def showPlot(arr, ddta = 5): 73 | fig = plt.figure() 74 | ax = fig.add_subplot(111) 75 | ax.scatter(arr[:,0], arr[:,1], 20, arr[:,2]) 76 | average = getAveragePlot(arr[:,1]) 77 | ax.plot([-2000, 2000],[average, average], 'Green') 78 | tar = getFrequencyPlot(arr[:,0:2], average, wat_dta = ddta) 79 | ax.plot(tar[0], tar[1]) 80 | plt.show() 81 | 82 | def showPlotExtend(arr, ddta = 5, hideDot = 0, restrict_cl = (0,9999)): 83 | fig = plt.figure() 84 | ax = fig.add_subplot(111) 85 | if not hideDot: 86 | ax.scatter(arr[:,0], arr[:,1], 20, arr[:,2]) 87 | average = getAveragePlot(arr[:,1]) 88 | ax.plot([-2000, 2000],[average, average], 'Green') 89 | x, y1, y2 = getFrequencyPlot(arr, average, wat_dta = ddta, restrict_cl = restrict_cl) 90 | ax.plot(x, y1) 91 | ax.plot(x, y2) 92 | plt.show() 93 | 94 | 95 | if __name__=='__main__': 96 | WAE.echoGraph() -------------------------------------------------------------------------------- /watterson_analysis_echo.py: -------------------------------------------------------------------------------- 1 | import pickle_util 2 | import watterson_analysis 3 | from numpy import array 4 | 5 | def echoGraph(): 6 | 7 | dataList = pickle_util.load_arr_from_file('temp.arr') 8 | arr = [] 9 | for k in dataList: 10 | # (0)id (1)d5 (2)d10 (3)d15 (4)d1 (5)ma20 (6)lastCL (7)watIndex (8)rd1 (9)lastTime (10) name 11 | arr.append([k[7], k[8], k[6]]) 12 | arr = array(arr) 13 | watterson_analysis.showPlotExtend(arr, ddta = 5, hideDot = 1, restrict_cl = (0,9999)) 14 | 15 | if __name__ == '__main__': 16 | echoGraph() -------------------------------------------------------------------------------- /watterson_detector.py: -------------------------------------------------------------------------------- 1 | import time 2 | import thread 3 | import urllib 4 | 5 | def DetectThread(args): 6 | urll = args[0] 7 | callbackFunc = args[1] 8 | urlstream = urllib.urlopen(urll) 9 | udata = urlstream.read() 10 | callbackFunc(udata) 11 | thread.exit_thread() 12 | 13 | def printData(dt): 14 | print dt 15 | 16 | class ThreadManager(): 17 | def __init__(self): 18 | self.pool = [] 19 | def addDetect(self, args): 20 | thread.start_new_thread(DetectThread, (1,1)) 21 | 22 | if __name__=='__main__': 23 | tManager = ThreadManager() 24 | tManager.addDetect(['http://www.baidu.com', printData]) 25 | -------------------------------------------------------------------------------- /watterson_frame.py: -------------------------------------------------------------------------------- 1 | #coding: utf8 2 | 3 | import wx 4 | import random 5 | import watterson_lib 6 | import tdx2 7 | import afunc 8 | import watterson_analysis 9 | from numpy import * 10 | import math 11 | 12 | import pickle 13 | import sys 14 | 15 | class ConfigureManager: 16 | def __init__(self): 17 | self.configDict = {} 18 | def getConfig(self, para): 19 | return self.configDict[para] 20 | def setConfig(self, para, val): 21 | self.configDict[para] = val 22 | 23 | cm = ConfigureManager() 24 | 25 | cm.setConfig('INIT_POW', [1000,100] + [0 for k in range(36)]) 26 | cm.setConfig('MAX_LOAD_ITEM', 7777) 27 | cm.setConfig('FILTER1', 1) 28 | cm.setConfig('FILTER2', 1) 29 | cm.setConfig('FILTER3', 1) 30 | cm.setConfig('TEST_MODE', 1) 31 | cm.setConfig('PRE_DAY', 2) 32 | cm.setConfig('PRE_DAY_CHECK_DAY', 2) 33 | 34 | 35 | class MessageManager: 36 | def __init__(self, lbl): 37 | self.lbl = lbl 38 | def ShowMessage(self, str): 39 | self.lbl.SetLabel(str) 40 | 41 | def arr_save_to_file(arr, filename): 42 | outputfile = open(filename, 'wb') 43 | pickle.dump(arr, outputfile, -1) 44 | outputfile.close() 45 | 46 | def load_arr_from_file(filename): 47 | outputfile = open(filename, 'rb') 48 | arr = pickle.load(outputfile) 49 | outputfile.close() 50 | return arr 51 | 52 | for k in sys.argv: 53 | if k=='-full': 54 | cm.setConfig('MAX_LOAD_ITEM', 7777) 55 | if k=='-test': 56 | cm.setConfig('TEST_MODE', 1) 57 | if k=='-real': 58 | cm.setConfig('TEST_MODE', 0) 59 | if k[:5] == '-pre=': 60 | cm.setConfig('PRE_DAY', float(k[5:])) 61 | 62 | varname = ['ID', 'd5', 'd10','d15', 'd1', 'ma20', 'last_cl', \ 63 | 'wattIndex','rd1','lastTime', 'name', 'd30',\ 64 | 'variance', 'd180', 'fast_grow', 'fast_fall', 'tdx_delta', 'delta_d1'] 65 | cm.setConfig('varname', varname) 66 | 67 | def config_varfunc(): 68 | 69 | if cm.getConfig('TEST_MODE'): 70 | PRE_DAY = cm.getConfig('PRE_DAY') 71 | else: 72 | PRE_DAY = 0 73 | 74 | varname = cm.getConfig('varname') 75 | 76 | varfunc = [lambda dl, sfid: sfid, \ 77 | lambda dl, sfid: watterson_lib.delta_ratio_reverse(dl, 5, PRE_DAY), \ 78 | lambda dl, sfid: watterson_lib.delta_ratio_reverse(dl, 10,PRE_DAY), \ 79 | lambda dl, sfid: watterson_lib.delta_ratio_reverse(dl, 15,PRE_DAY), \ 80 | lambda dl, sfid: watterson_lib.delta_ratio_reverse(dl, 1,PRE_DAY), \ 81 | lambda dl, sfid: float('%.2f'%watterson_lib.average(dl, 20, PRE_DAY)), \ 82 | lambda dl, sfid: dl[-1-PRE_DAY].cl, \ 83 | lambda dl, sfid: 'LV2 ratio', \ 84 | lambda dl, sfid: get_rd1(dl, sfid), \ 85 | lambda dl, sfid: watterson_lib.get_last_dline_ftime(dl,PRE_DAY), \ 86 | lambda dl, sfid: watterson_lib.get_stname(sfid), \ 87 | lambda dl, sfid: watterson_lib.delta_ratio_reverse(dl, 30, PRE_DAY), \ 88 | lambda dl, sfid: watterson_lib.variance(dl, 30, PRE_DAY), \ 89 | #lambda dl, sfid: watterson_lib.delta_ratio_reverse(dl, 180, PRE_DAY), \ 90 | lambda dl, sfid: 0, \ 91 | lambda dl, sfid: watterson_lib.fast_grow(dl, 30, PRE_DAY), \ 92 | lambda dl, sfid: watterson_lib.fast_fall(dl, 30, PRE_DAY), \ 93 | lambda dl, sfid: watterson_lib.tdx_delta(sfid, PRE_DAY),\ 94 | lambda dl, sfid: watterson_lib.delta_d1(dl,4,PRE_DAY)] 95 | 96 | cm.setConfig('varname', varname) 97 | cm.setConfig('varfunc', varfunc) 98 | 99 | 100 | ''' 101 | dratio(dl,time1, time2) = op(time2) - op(time1+time2) 102 | (x1,y1) = op(-5) - op(-5-15) 103 | (x,y) = op(-5+PRD) - op(-5) 104 | = op(y) - op(x+y) 105 | 106 | -5 = -PRE_DAY-1 # PRE_DAY = 4, MEAN -1,-2,-3,-4 107 | 108 | ''' 109 | 110 | 111 | def get_rd1(dl ,sfid): 112 | if cm.getConfig('TEST_MODE'): 113 | PD = cm.getConfig('PRE_DAY') 114 | PRD = cm.getConfig('PRE_DAY_CHECK_DAY') 115 | return watterson_lib.delta_ratio_reverse(dl,PRD,PD-PRD) 116 | else: 117 | return '_' 118 | 119 | def strr(k): 120 | if type(k) is str: 121 | return k 122 | else: 123 | try: 124 | return str(k) 125 | except: 126 | return 'ERR' 127 | 128 | def insertItem(lc, arr): 129 | index = lc.InsertStringItem(555, strr(arr[0])) 130 | for k in range(0, len(arr)): 131 | lc.SetStringItem(index, k, strr(arr[k])) 132 | 133 | def CreateDataList(dlinelist): 134 | config_varfunc() 135 | datalist = [] 136 | for item in dlinelist: 137 | dline = item[1] 138 | k = item[0] 139 | if cm.getConfig('FILTER3'): 140 | if dline[-1].op > 60: continue 141 | if len(dline) < 30: continue 142 | dataItem = [func(dline,k) for func in cm.getConfig('varfunc')] 143 | datalist.append(dataItem) 144 | return datalist 145 | 146 | 147 | def expd_func(k): 148 | if k<0: return math.exp(k) 149 | else: return k+1 150 | def expd_closeTo0(k): 151 | return math.exp(-abs(k)) 152 | 153 | def CalculateLv2Extend(k, pow = 0): 154 | ''' 155 | This is the KEY !!!!!! 156 | varname = ['ID', 'd5', 'd10','d15', 157 | 'd1', 'ma20', 'last_cl', \ 158 | 'wattIndex','rd1','lastTime', 'name', 159 | 'd30','variance', 'd180', 'fast_grow', 160 | 'fast_fall', 'tdx_delta', 'delta_d1'] 161 | ''' 162 | if pow==0: pow=cm.getConfig('INIT_POW') 163 | if k[6] == 0: return 0,0,0 164 | expd = lambda x:x 165 | #expd = expd_func 166 | d = [0 for t in range(10)] 167 | 168 | # ma20 - cl 169 | d[0] = expd((k[5] - k[6])/k[5]) * pow[0] 170 | # 势能 171 | d[1] = expd((-k[1]/10.0/5 * 5 -k[2]/10.0/10.0 - k[3]/10.0/15 ))* pow[1] 172 | # 一日势能 173 | d[2] = expd(-k[4]/10) * pow[2] 174 | # 波动股接近度 175 | d[3] = expd( expd_closeTo0(k[11]) * k[12] ) * pow[3] 176 | # 变权势能 1,2,3 177 | d[4] = expd( -k[1]/5 -k[2]/10*2 -k[3]/15*3 ) * pow[4]/10 178 | # d30 势能 179 | d[5] = expd( -k[11]/30 ) * pow[5] 180 | # 涨幅微分 181 | d[6] = k[17] * pow[6] 182 | 183 | ssum = 0 184 | sstr = '' 185 | ind = 0 186 | for k in d: 187 | ssum += k 188 | ind += 1 189 | sstr += str(ind) + '\n\t' + str(k) + '\n' 190 | sstr += 'Total=' + repr(ssum) 191 | return ssum, sstr 192 | 193 | class CommonFrame(wx.Frame): 194 | def __init__(self): 195 | 196 | # Generate Frame 197 | 198 | wx.Frame.__init__(self, None, -1, 'Watterson the Manager', 199 | size=(1900, 1000), 200 | style = wx.MINIMIZE_BOX | wx.MAXIMIZE_BOX |wx.SYSTEM_MENU | wx.CAPTION | wx.CLOSE_BOX) 201 | panel = wx.Panel(self, -1) 202 | 203 | MVW = 100 204 | MTH = 0 205 | 206 | listctrl = wx.ListCtrl(panel, -1, size=(1000 + MVW,920), pos=(30,20),style=wx.LC_REPORT) 207 | self.pageScroll = wx.ScrollBar(panel, -1, size = (300, 30), pos=(1060 + MVW, 20)) 208 | self.pageLabel = wx.StaticText(panel, -1, "PAGE=", size=(300,30), pos=(1060 + MVW,60)) 209 | self.sText = wx.TextCtrl(panel, -1, "", size=(600,400 + MTH), pos=(1060 + MVW, 100), style = wx.TE_MULTILINE) 210 | self.btnAnalysis = wx.Button(panel, -1, "PLOT", size=(120,40), pos = (1060+MVW, 520+MTH)) 211 | self.btnExportData = wx.Button(panel, -1, "EXPORT_DATA", size=(120,40), pos = (1200+MVW, 520+MTH)) 212 | if cm.getConfig('TEST_MODE'): s='toREAL' 213 | else: s='toTEST' 214 | self.btnTurnMode = wx.Button(panel, -1, s, size=(120,40), pos = (1400+MVW,20)) 215 | 216 | self.btnApply = wx.Button(panel, -1, "ApplyPow", size=(120,40), pos=(1060+MVW+200, 580+MTH)) 217 | self.textPow = wx.TextCtrl(panel, -1, str(cm.getConfig('INIT_POW')), size=(180, 40), pos=(1060+MVW, 580+MTH)) 218 | self.lblMsg = wx.StaticText(panel, -1, 'HAHA', size=(600,40), pos=(1060+MVW, 650+MTH)) 219 | 220 | self.btnAnalysis.Bind(wx.EVT_BUTTON, self.OnAnalysisClick) 221 | self.btnExportData.Bind(wx.EVT_BUTTON, self.OnExportClick) 222 | self.btnApply.Bind(wx.EVT_BUTTON, self.OnApplyPowClick) 223 | self.btnTurnMode.Bind(wx.EVT_BUTTON, self.OnTurnModeClick) 224 | 225 | self.pageScroll.SetScrollbar(0,100,1100,50) 226 | self.pageScroll.Bind(wx.EVT_SCROLL_CHANGED, self.OnScrollMove) 227 | 228 | varlist = cm.getConfig('varname') 229 | columnIndex = 0 230 | for i in varlist: 231 | listctrl.InsertColumn(9999, i + '_'+str(columnIndex)); 232 | columnIndex+=1 233 | 234 | listctrl.SetColumnWidth(0, 140) 235 | listctrl.SetColumnWidth(listctrl.GetColumnCount()-2, 140) 236 | listctrl.SetColumnWidth(listctrl.GetColumnCount()-1, 140) 237 | 238 | listctrl.Bind(wx.EVT_LIST_COL_CLICK, self.OnColClick) 239 | listctrl.Bind(wx.EVT_LIST_ITEM_FOCUSED, self.OnItemClick) 240 | 241 | self.listctrl = listctrl 242 | 243 | self.powConfig = cm.getConfig('INIT_POW') 244 | self.isReverse = True 245 | 246 | # Push Data 247 | 248 | tdx2.SetPath('Z:\\vipdoc', 'tdxpath') 249 | 250 | self.msgManager = MessageManager(self.lblMsg) 251 | self.LoadFile() 252 | self.Center() 253 | 254 | def OnExportClick(self, event): 255 | arr_save_to_file(self.dataList, 'temp.arr') 256 | self.msgManager.ShowMessage('Exported.') 257 | 258 | def OnApplyPowClick(self, event): 259 | sr = self.textPow.GetValue().replace('[', '').replace(']','') 260 | sr = sr.split(',') 261 | qr = [0 for k in range(36)] 262 | for k in range(min(36,len(sr))): 263 | qr[k] = float(sr[k]) 264 | self.powConfig = qr 265 | 266 | self.CalculateLv2(self.dataList) 267 | self.ListControlRefresh() 268 | 269 | def OnAnalysisClick(self, event): 270 | if not cm.getConfig('TEST_MODE'): 271 | self.msgManager.ShowMessage("THIS IS FOR TEST MODE ONLY") 272 | return 273 | arr = [] 274 | for k in self.dataList: 275 | # (0)id (1)d5 (2)d10 (3)d15 (4)d1 (5)ma20 (6)lastCL (7)watIndex (8)rd1 (9)lastTime (10) name 276 | arr.append([k[7], k[8], k[6]]) 277 | arr = array(arr) 278 | watterson_analysis.showPlot(arr) 279 | def LoadFile(self): 280 | # get list 281 | flist = tdx2.get_file_list() 282 | self.msgManager.ShowMessage('total file count:'+ str(len(flist))) 283 | flist = flist[:cm.getConfig('MAX_LOAD_ITEM')] 284 | 285 | # filter_2 286 | rflist = [] 287 | for k in flist: 288 | if cm.getConfig('FILTER1'): 289 | if k[:3] == "sh0": continue 290 | if k[:3] == "sh1": continue 291 | if k[:3] == "sh2": continue 292 | if k[:3] == "sh3": continue 293 | if k[:3] == "sh5": continue 294 | if k[:3] == "sh8": continue 295 | #if k[:3] == "sh5": continue 296 | rflist.append(k) 297 | 298 | flist = rflist 299 | 300 | # read file main 301 | gauage = 0 302 | dlinelist = [] 303 | for k in flist: 304 | dline = tdx2.get_dayline_by_fid(k, restrictSize = 40) 305 | dlinelist.append([k,dline]) 306 | gauage+=1 307 | if gauage%100 == 0: print gauage / 33, '%' 308 | self.dlinelist = dlinelist 309 | self.LoadProcess() 310 | def LoadProcess(self): 311 | datalist = CreateDataList(self.dlinelist) 312 | # filter 313 | maxd = 0 314 | for k in range(min(999,len(datalist))): maxd = max(datalist[k][9], maxd) 315 | if cm.getConfig('FILTER2'): 316 | filteredList = [] 317 | for k in datalist: 318 | if k[9] != maxd: continue 319 | if k[10] == 'na': continue 320 | filteredList.append(k) 321 | datalist = filteredList 322 | 323 | self.dataList = datalist 324 | self.CalculateLv2(datalist) 325 | self.msgManager.ShowMessage('data loading finished') 326 | 327 | watterson_lib.reInit() 328 | 329 | self.ListControlRefresh() 330 | 331 | def CalculateLv2(self, dataList): 332 | 333 | for k in dataList: 334 | condata = CalculateLv2Extend(k, self.powConfig) 335 | k[7] = condata[0] 336 | 337 | def OnColClick(self,event): 338 | self.pageScroll.SetThumbPosition(0) 339 | srtIndex = event.GetColumn() 340 | self.isReverse = not self.isReverse 341 | self.dataList.sort(key = lambda x: x[srtIndex], reverse = self.isReverse) 342 | self.ListControlRefresh() 343 | def OnTurnModeClick(self, event): 344 | if cm.getConfig('TEST_MODE'): 345 | cm.setConfig('TEST_MODE', 0) # turn to real mode 346 | self.LoadProcess() 347 | self.btnTurnMode.SetLabel("toTEST") 348 | else: 349 | cm.setConfig('TEST_MODE', 1) # turn to test mode 350 | self.LoadProcess() 351 | self.btnTurnMode.SetLabel("toREAL") 352 | def OnItemClick(self, event): 353 | for k in self.dataList: 354 | if k[0] == self.listctrl.GetItemText(self.listctrl.GetFocusedItem()): 355 | ls, mstr = CalculateLv2Extend(k, self.powConfig) 356 | self.sText.SetValue(k[0] + '\n'+mstr) 357 | def ListControlRefresh(self): 358 | self.msgManager.ShowMessage('Refresh') 359 | self.listctrl.DeleteAllItems() 360 | p=self.pageScroll.GetThumbPosition() 361 | self.pageLabel.SetLabel("PAGE=%d"%p) 362 | 363 | for k in self.dataList[p*36:36+p*36]: 364 | insertItem(self.listctrl, k) 365 | 366 | #wx.Event().GetEventObject() 367 | def OnScrollMove(self, event): 368 | sstr= 'page=' + str(event.GetEventObject().GetThumbPosition()) 369 | self.msgManager.ShowMessage(sstr) 370 | self.ListControlRefresh() 371 | 372 | if __name__ == '__main__': 373 | app = wx.PySimpleApp() 374 | CommonFrame().Show() 375 | app.MainLoop() -------------------------------------------------------------------------------- /watterson_lib.py: -------------------------------------------------------------------------------- 1 | 2 | #coding: utf8 3 | 4 | import tdx2 5 | import math 6 | 7 | qlist = [] 8 | 9 | def wattIndex(dline): 10 | return 0 11 | 12 | def delta_d1(dline, pd, preday=0): 13 | ud = [0 for k in range(pd)] 14 | for k in range(pd): 15 | ud[k] = dline[-1-preday -pd+k].cl 16 | for k in range(pd-1): 17 | ud[k] = ud[k+1]-ud[k] 18 | for k in range(pd-1): 19 | if ud[k] > ud[k+1]: return 0 20 | return 1 21 | 22 | def variance(dline, tlength, preday=0): 23 | st = len(dline) - preday - tlength 24 | en = len(dline) - preday 25 | avrg = average(dline, tlength, preday) 26 | ssum = 0 27 | for k in dline[st:en]: 28 | ssum += math.pow(k.cl - avrg,2) 29 | ssum = math.sqrt(ssum / (en-st)) 30 | return ssum 31 | 32 | def average(dline, tlength, preday=0): 33 | sum = 0 34 | st = len(dline) - preday - tlength 35 | en = len(dline) - preday 36 | for k in dline[st:en]: 37 | sum += k.cl 38 | return float(sum) / tlength 39 | 40 | def tdx_delta(fid, preday): 41 | return snm.get_tdx_delta(fid) 42 | 43 | def fast_grow(dline, daylength, preday): 44 | st = len(dline) - daylength - preday 45 | en = len(dline) - preday 46 | maxr = -9999 47 | for k in range(st+3,en): 48 | a = dline[k].cl 49 | b = dline[k-3].cl 50 | if (a-b)/b > maxr: 51 | maxr = (a-b)/b 52 | return maxr*100 53 | 54 | def fast_fall(dline, daylength, preday): 55 | st = len(dline) - daylength - preday 56 | en = len(dline) - preday 57 | minr = 9999 58 | for k in range(st+3,en): 59 | a = dline[k].cl 60 | b = dline[k-3].cl 61 | if (a-b)/b < minr: 62 | minr = (a-b)/b 63 | return minr*100 64 | 65 | def delta_ratio_reverse(dline, daylength, preday): 66 | 67 | # delta_ratio(-30, -1) 68 | a = dline[-1-preday].cl 69 | if -1-preday-daylength < -len(dline): return 0 70 | b = dline[-1-preday-daylength].cl 71 | return (float(a-b)/b*100) 72 | 73 | def get_last_dline_ftime(dline, preday=0): 74 | return tdx2.parse_time_reverse(dline[-1-preday].ftime+1) 75 | 76 | def reInit(): 77 | snm.reInit() 78 | 79 | 80 | class StNameManager(): 81 | def __init__(self): 82 | self.reInit() 83 | def reInit(self): 84 | f = open(u'C:\\new_tdx\\T0002\\export\\深沪Ａ股.TXT', 'r') 85 | qlist = [] 86 | for k in range(9999): 87 | s = f.readline() 88 | if not s: break 89 | s = s.split('\t') 90 | qlist.append(s) 91 | self.qlist = qlist 92 | 93 | def get_stname(self, fid): 94 | if len(fid)==12: fid = fid[2:8] 95 | for k in self.qlist: 96 | if k[0] == fid: 97 | return k[1] + ('=' + k[3]).encode('utf8') 98 | return 'na' 99 | def get_tdx_delta(self, fid): 100 | if len(fid)==12: fid = fid[2:8] 101 | for k in self.qlist: 102 | if k[0] == fid: 103 | try: 104 | return float(k[2]) 105 | except: 106 | print 'tdx_data,', k[2],'not float' 107 | return -99 108 | return -99 109 | 110 | def get_stname(fid): 111 | return snm.get_stname(fid) 112 | 113 | snm = StNameManager() 114 | 115 | if __name__ == '__main__': 116 | #print get_stname('sh000001.day') 117 | dl = tdx2.get_dayline_by_fid('sz002245', restrictSize=30) 118 | print len(dl) 119 | print fast_fall(dl, 30, 0) -------------------------------------------------------------------------------- /watterson_list_disp.py: -------------------------------------------------------------------------------- 1 | import pickle_util 2 | 3 | ''' 4 | varname = ['ID', 'd5', 'd10','d15', 5 | 'd1', 'ma20', 'last_cl','wattIndex', 6 | 'rd1','lastTime', 'name', 'd30',\ 7 | 'variance', 'd180', 'fast_grow', 'fast_fall', 8 | 'tdx_delta'] 9 | ''' 10 | def turnArrayToFile(arr): 11 | 12 | # get max day num 13 | maxd = 0 14 | for k in range(0,50): 15 | maxd = max(maxd, arr[k][9]) 16 | 17 | # write to file 18 | f = open('arr'+ str(maxd)+'.txt', 'w') 19 | for k in range(0,500): 20 | sstr = str(arr[k][10])+'\t'+ str(arr[k][7])+'\t'+ str(arr[k][14])+'\t'+ str(arr[k][15]) 21 | f.write(sstr+'\n') 22 | f.close() 23 | 24 | if __name__=='__main__': 25 | arr = pickle_util.load_arr_from_file('temp0331.arr') 26 | turnArrayToFile(arr) 27 | 28 | -------------------------------------------------------------------------------- /watterson_test.py: -------------------------------------------------------------------------------- 1 | import watterson_lib 2 | import tdx2 3 | 4 | dline = tdx2.get_dayline_by_fid('sh000001', 5) 5 | 6 | a = 1 7 | for k in dline: 8 | a = a + 1 9 | k.cl=a 10 | 11 | for k in dline: 12 | print k.ftime,k.cl 13 | 14 | pd = 3 15 | prd = 2 16 | d1 = watterson_lib.delta_ratio_reverse(dline, 1, 1) 17 | d2 = watterson_lib.delta_ratio_reverse(dline, 1, 0) 18 | d3 = watterson_lib.average(dline, 2, 0) 19 | d4 = watterson_lib.variance(dline, 2, 0) 20 | print d1, d2, d3, d4 --------------------------------------------------------------------------------