API tools faq
paste
Advertisement
ImDerekD

pscenarios.py

ImDerekD
Feb 16th, 2020
148
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 14.62 KB | None | 0 0
raw download clone embed print report
  1. #!/usr/bin/env python
  2. # coding: utf-8
  3.  
  4. # In[54]:
  5.  
  6.  
  7. #!/usr/bin/bash python
  8. # coding: utf-8
  9.  
  10. import pandas as pd
  11. import numpy as np
  12. import matplotlib.pyplot as plt
  13. import csv
  14. import warnings
  15. df = pd.read_csv('/Users/King/TA_SPY.csv')
  16. df1 = pd.read_csv('/Users/King/SPY_var_analysis.csv')
  17.  
  18. import warnings
  19. warnings.filterwarnings("ignore")
  20.  
  21. df1['PVP'] = 100*round(df1.PVS / df1.Price, 4)
  22. df1['PVS'] = df1.PVP
  23. del df1['PVP']
  24.  
  25.  
  26. df['PVP'] = 100*round(df.PVS / df.Price, 4)
  27. df['PVS'] = df.PVP
  28. del df['PVP']
  29.  
  30. with open('/Users/King/SPY_var_analysis.csv', 'r') as csv_file:
  31. reader = csv.reader(csv_file)
  32. header = next(reader)
  33. for row in reader:
  34. Date = str(row[0])
  35. Time = str(row[1])
  36. ref_Num = float(row[2])
  37. Price = float(row[3])
  38. ChgO = float(row[4])
  39. PG = float(row[5])
  40. MTR = float(row[6])
  41. DR = float(row[7])
  42. GR = float(row[8])
  43. GDR = float(row[9])
  44. PVS = float(row[10])
  45. avgVol = float(row[11])
  46. ITDS = float(row[12])
  47. NS = float(row[13])
  48. SS = float(row[14])
  49. AQR = float(row[15])
  50. ALQ = float(row[16])
  51. UDR = float(row[17])
  52. CVSR = float(row[18])
  53. QRS = float(row[19])
  54. AVSR = float(row[20])
  55. DRC = int(row[21])
  56. CashOpen = float(row[22])
  57. Liquidity = float(row[23])
  58. MTR_Strength = float(row[24])
  59. UDR_Strength = float(row[25])
  60. Chg45 = float(row[26])
  61. Chg60 = float(row[27])
  62. Chg120 = float(row[28])
  63. PVP = 100*round(PVS / Price, 4)
  64. VOL_QR = round((avgVol / AQR) - CVSR, 3)
  65.  
  66.  
  67. match_time = df.ref_Num == ref_Num
  68. avg_bin = 5
  69.  
  70. matches = df[['Date', 'Time', 'ChgO', 'PG', 'MTR', 'DR', 'GR', 'GDR', 'PVS', 'avgVol', 'ITDS', 'NS', 'SS', 'avgQR', 'QRS_Index', 'ALQ', 'UDR', 'VSR', '60Min', '120Min', '180Min', '240Min', '1D', '3D']][match_time]
  71.  
  72. chgo_max = matches.iloc[:, 2].max()
  73. chgo_min = matches.iloc[:, 2].min()
  74. chgo_range = abs(chgo_max - chgo_min)
  75. chgo_move = abs(chgo_range / 9)
  76.  
  77.  
  78. cur_ChgO_bin = round((ChgO - chgo_min) / chgo_move, 0)
  79. scen_ChgO_bin = round((df.ChgO - chgo_min) / chgo_move, 0)
  80. ChgOMatch = scen_ChgO_bin == cur_ChgO_bin
  81.  
  82. pm = df[['Date', 'Time', 'ChgO', 'PG', 'MTR', 'DR', 'GR', 'GDR', 'PVS', 'avgVol', 'ITDS', 'NS', 'SS', 'avgQR', 'QRS_Index', 'ALQ', 'UDR', 'VSR', '60Min', '120Min', '180Min', '240Min']][match_time][ChgOMatch]
  83.  
  84.  
  85. pg_max = matches.iloc[:, 3].max()
  86. pg_min = matches.iloc[:, 3].min()
  87. pg_range = abs(pg_max - pg_min)
  88. pg_move = abs(pg_range / avg_bin)
  89.  
  90. cur_PG_bin = round((PG - pg_min) / pg_move, 0)
  91. scen_PG_bin = round((df.PG - pg_min) / pg_move, 0)
  92.  
  93. PGMatch = scen_PG_bin == cur_PG_bin
  94.  
  95.  
  96. mtr_max = matches.iloc[:, 4].max()
  97. mtr_min = matches.iloc[:, 4].min()
  98. mtr_range = abs(mtr_max - mtr_min)
  99. mtr_move = abs(mtr_range / avg_bin)
  100.  
  101. cur_MTR_bin = round((MTR - mtr_min) / mtr_move, 0)
  102. scen_MTR_bin = round((df.MTR - mtr_min) / mtr_move, 0)
  103.  
  104. MTRMatch = scen_MTR_bin == cur_MTR_bin
  105.  
  106.  
  107.  
  108. dr_max = matches.iloc[:, 5].max()
  109. dr_min = matches.iloc[:, 5].min()
  110. dr_range = abs(dr_max - dr_min)
  111. dr_move = abs(dr_range / avg_bin)
  112.  
  113. cur_DR_bin = round((DR - dr_min) / dr_move, 0)
  114. scen_DR_bin = round((df.DR - dr_min) / dr_move, 0)
  115.  
  116. DRMatch = scen_DR_bin == cur_DR_bin
  117.  
  118.  
  119.  
  120.  
  121. gr_max = matches.iloc[:, 6].max()
  122. gr_min = matches.iloc[:, 6].min()
  123. gr_range = abs(gr_max - gr_min)
  124. gr_move = abs(gr_range / avg_bin)
  125.  
  126. cur_GR_bin = round((GR - gr_min) / gr_move, 0)
  127. scen_GR_bin = round((df.GR - gr_min) / gr_move, 0)
  128.  
  129. GRMatch = scen_GR_bin == cur_GR_bin
  130.  
  131.  
  132.  
  133. gdr_max = matches.iloc[:, 7].max()
  134. gdr_min = matches.iloc[:, 7].min()
  135. gdr_range = abs(gdr_max - gdr_min)
  136. gdr_move = abs(gdr_range / avg_bin)
  137.  
  138.  
  139. cur_GDR_bin = round((GDR - gdr_min) / gdr_move, 0)
  140. scen_GDR_bin = round((df.GDR - gdr_min) / gdr_move, 0)
  141.  
  142. GDRMatch = scen_GDR_bin == cur_GDR_bin
  143.  
  144. #set6 = df[match_time][GDRMatch]
  145. ##set6
  146.  
  147.  
  148. pvs_max = matches.iloc[:, 8].max()
  149. pvs_min = matches.iloc[:, 8].min()
  150. pvs_range = abs(pvs_max - pvs_min)
  151. pvs_move = abs(pvs_range / avg_bin)
  152.  
  153. cur_PVS_bin = round((PVP - pvs_min) / pvs_move, 0)
  154. scen_PVS_bin = round((df.PVS - pvs_min) / pvs_move, 0)
  155.  
  156. PVSMatch = scen_PVS_bin == cur_PVS_bin
  157.  
  158.  
  159. vol_max = matches.iloc[:, 9].max()
  160. vol_min = matches.iloc[:, 9].min()
  161. vol_range = abs(vol_max - vol_min)
  162. vol_move = abs(vol_range / avg_bin)
  163.  
  164. cur_VOL_bin = round((avgVol - vol_min) / vol_move, 0)
  165. scen_VOL_bin = round((df.avgVol - vol_min) / vol_move, 0)
  166.  
  167. VOLMatch = scen_VOL_bin == cur_VOL_bin
  168.  
  169.  
  170. itds_max = matches.iloc[:, 10].max()
  171. itds_min = matches.iloc[:, 10].min()
  172. itds_range = abs(itds_max - itds_min)
  173. itds_move = abs(itds_range / avg_bin)
  174.  
  175. cur_ITDS_bin = round((ITDS - itds_min) / itds_move, 0)
  176. scen_ITDS_bin = round((df.ITDS - itds_min) / itds_move, 0)
  177.  
  178. ITDSMatch = scen_ITDS_bin == cur_ITDS_bin
  179.  
  180.  
  181.  
  182. ns_max = matches.iloc[:, 11].max()
  183. ns_min = matches.iloc[:, 11].min()
  184. ns_range = abs(ns_max - ns_min)
  185. ns_move = abs(ns_range / avg_bin)
  186.  
  187. cur_NS_bin = round((NS - ns_min) / ns_move, 0)
  188. scen_NS_bin = round((df.NS - ns_min) / ns_move, 0)
  189.  
  190. NSMatch = scen_NS_bin == cur_NS_bin
  191.  
  192.  
  193. ss_max = matches.iloc[:, 12].max()
  194. ss_min = matches.iloc[:, 12].min()
  195. ss_range = abs(ss_max - ss_min)
  196. ss_move = abs(ss_range / avg_bin)
  197.  
  198. cur_SS_bin = round((SS - ss_min) / ss_move, 0)
  199. scen_SS_bin = round((df.SS - ss_min) / ss_move, 0)
  200.  
  201. SSMatch = scen_SS_bin == cur_SS_bin
  202.  
  203.  
  204. aqr_max = matches.iloc[:, 13].max()
  205. aqr_min = matches.iloc[:, 13].min()
  206. aqr_range = abs(aqr_max - aqr_min)
  207. aqr_move = abs(aqr_range / avg_bin)
  208.  
  209. cur_AQR_bin = round((AQR - aqr_min) / aqr_move, 0)
  210. scen_AQR_bin = round((df.avgQR - aqr_min) / aqr_move, 0)
  211.  
  212. AQRMatch = scen_AQR_bin == cur_AQR_bin
  213.  
  214.  
  215. qrs_max = matches.iloc[:, 14].max()
  216. qrs_min = matches.iloc[:, 14].min()
  217. qrs_range = abs(qrs_max - qrs_min)
  218. qrs_move = abs(qrs_range / avg_bin)
  219.  
  220. cur_QRS_bin = round((QRS - qrs_min) / qrs_move, 0)
  221. scen_QRS_bin = round((df.QRS_Index - qrs_min) / qrs_move, 0)
  222.  
  223. QRSMatch = scen_QRS_bin == cur_QRS_bin
  224.  
  225.  
  226. alq_max = matches.iloc[:, 15].max()
  227. alq_min = matches.iloc[:, 15].min()
  228. alq_range = abs(alq_max - alq_min)
  229. alq_move = abs(alq_range / avg_bin)
  230.  
  231. cur_ALQ_bin = round((AQR - alq_min) / alq_move, 0)
  232. scen_ALQ_bin = round((df.ALQ - alq_min) / alq_move, 0)
  233.  
  234. ALQMatch = scen_ALQ_bin == cur_ALQ_bin
  235.  
  236.  
  237. udr_max = matches.iloc[:, 16].max()
  238. udr_min = matches.iloc[:, 16].min()
  239. udr_range = abs(udr_max - udr_min)
  240. udr_move = abs(udr_range / avg_bin)
  241.  
  242. cur_UDR_bin = round((UDR - udr_min) / udr_move, 0)
  243. scen_UDR_bin = round((df.UDR - udr_min) / udr_move, 0)
  244.  
  245. UDRMatch = scen_UDR_bin == cur_UDR_bin
  246.  
  247.  
  248. vsr_max = matches.iloc[:, 17].max()
  249. vsr_min = matches.iloc[:, 17].min()
  250. vsr_range = abs(vsr_max - vsr_min)
  251. vsr_move = abs(vsr_range / avg_bin)
  252.  
  253. cur_VSR_bin = round((CVSR - vsr_min) / vsr_move, 0)
  254. scen_VSR_bin = round((df.VSR - vsr_min) / vsr_move, 0)
  255. VSRMatch = scen_VSR_bin == cur_VSR_bin
  256.  
  257.  
  258. avg_vsr_max = matches.iloc[:, 18].max()
  259. avg_vsr_min = matches.iloc[:, 18].min()
  260. avg_vsr_range = abs(avg_vsr_max - avg_vsr_min)
  261. avg_vsr_move = abs(avg_vsr_range / avg_bin)
  262.  
  263. cur_avg_vsr_bin = round((AVSR - avg_vsr_min) / avg_vsr_move, 0)
  264. scen_avg_vsr_bin = round((df.avgVSR - avg_vsr_min) / avg_vsr_move, 0)
  265. AVGVSRMatch = scen_avg_vsr_bin == cur_avg_vsr_bin
  266.  
  267.  
  268. ##################################################################################################
  269.  
  270. def outlier():
  271. outlier_count = int()
  272.  
  273. for i in dist:
  274. if i >= .74:
  275. outlier_count += 1
  276.  
  277. if outlier_count < 2 and outlier_count == 1:
  278. print('HAS OUTLIER')
  279. if outlier_count >= 2:
  280. print('HAS %s OUTLIERS' % outlier_count)
  281.  
  282. return
  283. ###############################################################################
  284.  
  285.  
  286. avg_df_chgo = np.mean(df[match_time].ChgO)
  287. avg_df_chgo_dist = round(abs(ChgO - avg_df_chgo) / avg_df_chgo, 2)
  288.  
  289. avg_df_mtr = np.mean(df[match_time].MTR)
  290. avg_df_mtr_dist = round(abs(MTR - avg_df_mtr) / avg_df_mtr, 2)
  291.  
  292. avg_df_pg = np.mean(df[match_time].PG)
  293. avg_df_pg_dist = round(abs(PG - avg_df_pg) / avg_df_pg, 2)
  294.  
  295. avg_df_dr = np.mean(df[match_time].DR)
  296. avg_df_dr_dist = round(abs(DR - avg_df_dr) / avg_df_dr, 2)
  297.  
  298. avg_df_gr= np.mean(df[match_time].GR)
  299. avg_df_gr_dist = round(abs(GR - avg_df_gr) / avg_df_gr, 2)
  300.  
  301. avg_df_gdr = np.mean(df[match_time].GDR)
  302. avg_df_gdr_dist = round(abs(GDR - avg_df_gdr) / avg_df_gdr, 2)
  303.  
  304. avg_df_pvs = np.mean(df[match_time].PVS)
  305. avg_df_pvs_dist = round(abs(PVP - avg_df_pvs) / avg_df_pvs, 2)
  306.  
  307. avg_df_alq = np.mean(df[match_time].ALQ)
  308. avg_df_alq_dist = round(abs(ALQ - avg_df_alq) / avg_df_alq, 2)
  309.  
  310. avg_df_ss = np.mean(df[match_time].SS)
  311. avg_df_ss_dist = round(abs(SS - avg_df_ss) / avg_df_ss, 2)
  312.  
  313. avg_df_vol = np.mean(df[match_time].avgVol)
  314. avg_df_avol_dist = round(abs(avgVol - avg_df_vol) / avg_df_vol, 2)
  315.  
  316. avg_df_aqr = np.mean(df[match_time].avgQR)
  317. avg_df_aqr_dist = round(abs(AQR - avg_df_aqr) / avg_df_aqr, 2)
  318.  
  319. avg_df_qrs = np.mean(df[match_time].QRS_Index)
  320. avg_df_qrs_dist = round(abs(QRS - avg_df_qrs) / avg_df_qrs, 2)
  321.  
  322. avg_df_vsr = np.mean(df[match_time].VSR)
  323. avg_df_vsr_dist = round(abs(CVSR - avg_df_vsr) / avg_df_vsr, 2)
  324.  
  325. avg_df_udr = np.mean(df[match_time].UDR)
  326. avg_df_udr_dist = round(abs(UDR - avg_df_udr) / avg_df_udr, 2)
  327.  
  328. avg_df_drc = np.mean(df[match_time].DRC)
  329. avg_df_drc_dist = round(abs(DRC - avg_df_drc) / avg_df_drc, 2)
  330.  
  331. #####################################################################
  332.  
  333.  
  334.  
  335. avg_chgo = np.mean(df[match_time][ChgOMatch].ChgO)
  336. avg_chgo_dist = round(abs(ChgO - avg_chgo) / avg_chgo, 2)
  337.  
  338. avg_mtr = np.mean(df[match_time][ChgOMatch].MTR)
  339. avg_mtr_dist = round(abs(MTR - avg_mtr) / avg_mtr, 2)
  340.  
  341. avg_pg = np.mean(df[match_time][ChgOMatch].PG)
  342. avg_pg_dist = round(abs(PG - avg_pg) / avg_pg, 2)
  343.  
  344. avg_dr = np.mean(df[match_time][ChgOMatch].DR)
  345. avg_dr_dist = round(abs(DR - avg_dr) / avg_dr, 2)
  346.  
  347. avg_gr= np.mean(df[match_time][ChgOMatch].GR)
  348. avg_gr_dist = round(abs(GR - avg_gr) / avg_gr, 2)
  349.  
  350. avg_gdr = np.mean(df[match_time][ChgOMatch].GDR)
  351. avg_gdr_dist = round(abs(GDR - avg_gdr) / avg_gdr, 2)
  352.  
  353. avg_pvs = np.mean(df[match_time][ChgOMatch].PVS)
  354. avg_pvs_dist = round(abs(PVP - avg_pvs) / avg_pvs, 2)
  355.  
  356. avg_alq = np.mean(df[match_time][ChgOMatch].ALQ)
  357. avg_alq_dist = round(abs(ALQ - avg_alq) / avg_alq, 2)
  358.  
  359. avg_ss = np.mean(df[match_time][ChgOMatch].SS)
  360. avg_ss_dist = round(abs(SS - avg_ss) / avg_ss, 2)
  361.  
  362. avg_vol = np.mean(df[match_time][ChgOMatch].avgVol)
  363. avg_avol_dist = round(abs(avgVol - avg_vol) / avg_vol, 2)
  364.  
  365. avg_aqr = np.mean(df[match_time][ChgOMatch].avgQR)
  366. avg_aqr_dist = round(abs(AQR - avg_aqr) / avg_aqr, 2)
  367.  
  368. avg_qrs = np.mean(df[match_time][ChgOMatch].QRS_Index)
  369. avg_qrs_dist = round(abs(QRS - avg_qrs) / avg_qrs, 2)
  370.  
  371. avg_vsr = np.mean(df[match_time][ChgOMatch].VSR)
  372. avg_vsr_dist = round(abs(CVSR - avg_vsr) / avg_vsr, 2)
  373.  
  374. avg_udr = np.mean(df[match_time][ChgOMatch].UDR)
  375. avg_udr_dist = round(abs(UDR - avg_udr) / avg_udr, 2)
  376.  
  377. avg_drc = np.mean(df[match_time][ChgOMatch].DRC)
  378. avg_drc_dist = round(abs(DRC - avg_drc) / avg_drc, 2)
  379.  
  380. ################################################################################
  381.  
  382. oval_mtr_dist = round(avg_df_mtr_dist + avg_mtr_dist, 2)
  383. oval_pg_dist = round(avg_df_mtr_dist + avg_mtr_dist, 2)
  384. oval_dr_dist = round(avg_df_dr_dist + avg_dr_dist, 2)
  385. oval_gr_dist = round(avg_df_gr_dist + avg_gr_dist, 2)
  386. oval_gdr_dist = round(avg_df_gdr_dist + avg_gdr_dist, 2)
  387. oval_pvs_dist = round(avg_df_pvs_dist + avg_pvs_dist, 2)
  388. oval_alq_dist = round(avg_df_alq_dist + avg_alq_dist, 2)
  389. oval_avol_dist = round(avg_df_avol_dist + avg_avol_dist, 2)
  390. oval_ss_dist = round(avg_df_ss_dist + avg_ss_dist, 2)
  391. oval_aqr_dist = round(avg_df_aqr_dist + avg_aqr_dist, 2)
  392. oval_qrs_dist = round(avg_df_qrs_dist + avg_qrs_dist, 2)
  393. oval_vsr_dist = round(avg_df_vsr_dist + avg_vsr_dist, 2)
  394. oval_udr_dist = round(avg_df_udr_dist + avg_udr_dist, 2)
  395. oval_drc_dist = round(avg_df_drc_dist + avg_drc_dist, 2)
  396.  
  397.  
  398.  
  399. dist = [avg_mtr_dist, avg_pg_dist, avg_dr_dist, avg_gr_dist, avg_gdr_dist, avg_avol_dist, avg_ss_dist, avg_aqr_dist, avg_qrs_dist, avg_vsr_dist, avg_udr_dist, avg_drc_dist]
  400.  
  401. indent = ' '
  402. print('MTR'+indent+'PG'+indent+'DR'+indent+'GR'+indent+'GDR'+indent+'Vol'+indent+'ALQ'+indent+'SS'+indent+'QR'+indent+'QRS'+indent+'VSR'+indent+'UDR'+indent+'DRC')
  403. print(avg_mtr_dist, avg_pg_dist, avg_dr_dist, avg_gr_dist, avg_gdr_dist, avg_avol_dist, avg_alq_dist, avg_ss_dist, avg_aqr_dist, avg_qrs_dist, avg_vsr_dist, avg_udr_dist, avg_drc_dist)
  404.  
  405. outlier()
  406.  
  407. indt = ' '
  408. print('mtr'+indt+' pg'+indt+' dr'+indt+'gr'+indt+'gdr'+indt+'alq'+indt+'vol'+indt+' ss'+indt+'aqr'+indt+'qrs'+indt+'vsr'+indt+'udr'+indt+'drc')
  409. print(oval_mtr_dist, oval_pg_dist, oval_dr_dist, oval_gr_dist, oval_gdr_dist, oval_alq_dist, oval_avol_dist, oval_ss_dist, oval_aqr_dist, oval_qrs_dist, oval_vsr_dist, oval_udr_dist,oval_drc_dist)
  410.  
  411.  
  412. ChgORank = abs(ChgO - matches.ChgO).rank(ascending=True)
  413. ChgOMatch = ChgORank < 10
  414.  
  415. ALQRank = abs(ALQ - matches.ALQ).rank(ascending=True)
  416. ALQMatch = ALQRank < 10
  417.  
  418. QRSRank = abs(QRS - matches.QRS_Index).rank(ascending=True)
  419. QRSMatch = QRSRank < 10
  420.  
  421. SSRank = abs(SS - matches.SS).rank(ascending=True)
  422. SSMatch = SSRank < 10
  423.  
  424. DRRank = abs(DR - matches.DR).rank(ascending=True)
  425. DRMatch = DRRank < 10
  426.  
  427. PGRank = abs(PG - matches.PG).rank(ascending=True)
  428. PGMatch = PGRank < 10
  429.  
  430. VOLRank = abs(avgVol - matches.avgVol).rank(ascending=True)
  431. VOLMatch = VOLRank < 10
  432.  
  433. VSRRank = abs(CVSR - matches.VSR).rank(ascending=True)
  434. VSRMatch = VSRRank < 10
  435.  
  436. dict = {'MTR':oval_mtr_dist, 'PG':oval_pg_dist, 'DR':oval_dr_dist, 'GR':oval_gr_dist, 'GDR':oval_gdr_dist, 'ALQ':oval_alq_dist, 'AVOL':oval_avol_dist, 'SS':oval_ss_dist, 'AQR':oval_aqr_dist, 'QRS':oval_qrs_dist, 'VSR':oval_vsr_dist, 'UDR':oval_udr_dist,'DRC':oval_drc_dist}
  437.  
  438.  
  439. pm = []
  440. print('\n\n')
  441. for k,v in dict.items():
  442. if v >= 1.5:
  443.  
  444. print(k, v)
  445.  
  446.  
  447. if k+'Match' == 'ALQMatch':
  448. print(matches[ALQMatch])
  449.  
  450. if k+'Match' == 'QRSMatch':
  451. print(matches[QRSMatch])
  452.  
  453. if k+'Match' == 'VSRMatch':
  454. print(matches[VSRMatch])
  455.  
  456. if k+'Match' == 'AQRMatch':
  457. print(matches[AQRMatch])
  458.  
  459. matches['VOL_QR'] = round(matches.avgVol / matches.avgQR) - matches.VSR
  460. matches['AQVSR_cor'] = round((matches.VSR * matches.avgQR) / matches.avgVol, 3)
  461. nvRank = abs(matches.AQVSR_cor - 0).rank(ascending=True)
  462. nvMatch = nvRank < 10
  463.  
  464. print('\n\n\n')
  465. del matches['ITDS']
  466. del matches['NS']
  467. print(matches[nvMatch])
  468.  
  469. print('\n')
  470.  
  471. # curf = df1[['Date', 'Time', 'ChgO', 'PG', 'MTR', 'DR', 'GR', 'GDR', 'PVS', 'avgVol', 'ITDS', 'NS', 'SS', 'avgQR', 'QRS_Index', 'ALQ', 'UDR', 'VSR', 'VOL_QR']]
  472. print(df1[-1:])
  473.  
  474. matches['VOL_QRRank'] = abs(matches.VOL_QR - VOL_QR).rank(ascending=True)
  475. VOL_QRMatch = matches.VOL_QRRank < 10
  476.  
  477. print(matches[VOL_QRMatch])
  478. # print(matches[QRSMatch])
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!