def get_duration_Index_date(code="999999", dt=None):
if dt is not None:
if len(str(dt)) < 8:
dl = int(dt) + changedays
df = get_tdx_day_to_df(code).sort_index(ascending=False)
dt = get_duration_price_date(code, dt=dt, ptype=ptype, df=df)
dt = df[df.index <= dt].index.values[changedays]
log.info("LastDF:%s,%s" % (dt, dl))
else:
if len(str(dt)) == 8:
dt = cct.day8_to_day10(dt)
df = get_tdx_day_to_df(code).sort_index(ascending=False)
dl = len(get_tdx_Exp_day_to_df(code, start=dt)) + changedays
dt = df[df.index <= dt].index.values[changedays]
log.info("LastDF:%s,%s" % (dt, dl))
return dt, dl
return None, None
def get_tdx_exp_all_LastDF(codeList, dt=None, ptype="low"):
time_t = time.time()
# df = rl.get_sina_Market_json(market)
# code_list = np.array(df.code)
# if type==0:
# results = cct.to_mp_run(get_tdx_day_to_df_last, codeList)
# else:
if dt is not None:
if len(str(dt)) < 8:
dl = int(dt) + changedays
df = get_tdx_day_to_df("999999").sort_index(ascending=False)
dt = get_duration_price_date("999999", dt=dt, ptype=ptype, df=df)
dt = df[df.index <= dt].index.values[changedays]
log.info("LastDF:%s,%s" % (dt, dl))
else:
if len(str(dt)) == 8:
dt = cct.day8_to_day10(dt)
df = get_tdx_day_to_df("999999").sort_index(ascending=False)
dl = len(get_tdx_Exp_day_to_df("999999", start=dt)) + changedays
dt = df[df.index <= dt].index.values[changedays]
log.info("LastDF:%s,%s" % (dt, dl))
results = cct.to_mp_run_async(get_tdx_exp_low_or_high_price, codeList, dt, ptype, dl)
# results = get_tdx_exp_low_or_high_price(codeList[0], dt,ptype,dl)
# results=[]
# for code in codeList:
# results.append(get_tdx_exp_low_or_high_price(code, dt, ptype, dl))
else:
# results = cct.to_mp_run_async(get_tdx_exp_low_or_high_price,codeList)
results = cct.to_mp_run_async(get_tdx_Exp_day_to_df, codeList, "f", None, None, None, 1)
# print results
df = pd.DataFrame(results, columns=ct.TDX_Day_columns)
df = df.set_index("code")
df.loc[:, "open":] = df.loc[:, "open":].astype(float)
# df.vol = df.vol.apply(lambda x: x / 100)
log.info("get_to_mp:%s" % (len(df)))
log.info("TDXTime:%s" % (time.time() - time_t))
if dt != None:
print ("TDXE:%0.2f" % (time.time() - time_t)),
return df
def main_test():
run = 1
df = rl.get_sina_Market_json("cyb")
df = df.set_index("code")
codelist = df.index.tolist()
duration_date = 20160101
ptype = "low"
dt = duration_date
# codeList='999999'
print ""
for x in xrange(1):
if len(str(dt)) != 8:
df = get_tdx_day_to_df("999999").sort_index(ascending=False)
dt = get_duration_price_date("999999", dt=dt, ptype=ptype, df=df)
dt = df[df.index <= dt].index.values[changedays]
log.info("LastDF:%s" % dt)
else:
dt = int(dt) + changedays
# print dt
# top_now = rl.get_market_price_sina_dd_realTime(df, vol, type)
split_t = timeit.timeit(lambda: get_tdx_all_day_LastDF(codelist, dt=duration_date, ptype=ptype), number=run)
# split_t = timeit.timeit(lambda: get_tdx_day_to_df_last(codeList, 1, type, dt,ptype),number=run)
print ("df Read:", split_t)
dt = duration_date
if len(str(dt)) != 8:
dl = int(dt) + changedays
df = get_tdx_day_to_df("999999").sort_index(ascending=False)
dt = get_duration_price_date("999999", dt=dt, ptype=ptype, df=df)
dt = df[df.index <= dt].index.values[changedays]
log.info("LastDF:%s" % dt)
else:
df = get_tdx_day_to_df("999999").sort_index(ascending=False)
dl = len(get_tdx_Exp_day_to_df("999999", start=dt)) + changedays
dt = cct.day8_to_day10(dt)
# print dt,dl
# strip_tx = timeit.timeit(lambda: get_tdx_exp_low_or_high_price(codeList, dt, ptype, dl), number=run)
strip_tx = timeit.timeit(lambda: get_tdx_exp_all_LastDF(codelist, dt=duration_date, ptype=ptype), number=run)
print ("ex Read:", strip_tx)
def get_duration_price_date(code, ptype="low", dt=None, df="", dl=None, vtype=None):
if len(df) == 0:
df = get_tdx_day_to_df(code).sort_index(ascending=False)
log.debug("code:%s" % (df[:1].index))
if dt != None:
if len(str(dt)) == 10:
dz = df[df.index >= dt]
if dl is not None:
if len(dz) < int(dl) - changedays:
if len(df) > int(dl):
dz = df[: int(dl)]
else:
dz = df
else:
if len(df) > int(dl):
dz = df[: int(dl)]
else:
dz = df
elif len(str(dt)) == 8:
dt = cct.day8_to_day10(dt)
dz = df[df.index >= dt]
if dl is not None:
if len(dz) < int(dl) - changedays:
if len(df) > int(dl):
dz = df[: int(dl)]
else:
dz = df
else:
if len(df) > int(dl):
dz = df[: int(dl)]
else:
dz = df
else:
if len(df) > int(dt):
dz = df[: int(dt)]
else:
dz = df
elif dl is not None:
if len(df) > int(dl):
dz = df[: int(dl)]
else:
dz = df
return dz[-1:].index.values[0]
if ptype == "high":
lowp = dz.high.max()
lowdate = dz[dz.high == lowp].index.values[0]
log.debug("high:%s" % lowdate)
else:
lowp = dz.low.min()
lowdate = dz[dz.low == lowp].index.values[0]
log.debug("low:%s" % lowdate)
# if ptype == 'high':
# lowp = dz.close.max()
# lowdate = dz[dz.close == lowp].index.values[0]
# log.debug("high:%s"%lowdate)
# else:
# lowp = dz.close.min()
# lowdate = dz[dz.close == lowp].index.values[0]
# log.debug("low:%s"%lowdate)
log.debug("date:%s %s:%s" % (lowdate, ptype, lowp))
return lowdate
def get_linear_model_histogramDouble(code, ptype='f', dtype='d', start=None, end=None, vtype='close', filter='n',
df=None):
# 399001','cyb':'zs399006','zxb':'zs399005
# code = '999999'
# code = '601608'
# code = '000002'
# asset = ts.get_hist_data(code)['close'].sort_index(ascending=True)
# df = tdd.get_tdx_Exp_day_to_df(code, 'f').sort_index(ascending=True)
# vtype='close'
# if vtype == 'close' or vtype==''
# ptype=
if start is not None and filter == 'y':
if code not in ['999999', '399006', '399001']:
index_d, dl = tdd.get_duration_Index_date(dt=start)
log.debug("index_d:%s dl:%s" % (str(index_d), dl))
else:
index_d = cct.day8_to_day10(start)
log.debug("index_d:%s" % (index_d))
start = tdd.get_duration_price_date(code, ptype='low', dt=index_d)
log.debug("start:%s" % (start))
if df is None:
# df = tdd.get_tdx_append_now_df(code, ptype, start, end).sort_index(ascending=True)
df = tdd.get_tdx_append_now_df_api(code, ptype, start, end).sort_index(ascending=True)
if not dtype == 'd':
df = tdd.get_tdx_stock_period_to_type(df, dtype).sort_index(ascending=True)
asset = df[vtype]
log.info("df:%s" % asset[:1])
asset = asset.dropna()
dates = asset.index
if not code.startswith('999') or not code.startswith('399'):
if code[:1] in ['5', '6', '9']:
code2 = '999999'
elif code[:1] in ['3']:
code2 = '399006'
else:
code2 = '399001'
df1 = tdd.get_tdx_append_now_df_api(code2, ptype, start, end).sort_index(ascending=True)
# df1 = tdd.get_tdx_append_now_df(code2, ptype, start, end).sort_index(ascending=True)
if not dtype == 'd':
df1 = tdd.get_tdx_stock_period_to_type(df1, dtype).sort_index(ascending=True)
asset1 = df1.loc[asset.index, vtype]
startv = asset1[:1]
# asset_v=asset[:1]
# print startv,asset_v
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
# print asset1[:4]
# 画出价格随时间变化的图像
# _, ax = plt.subplots()
# fig = plt.figure()
fig = plt.figure(figsize=(16, 10))
# fig = plt.figure(figsize=(16, 10), dpi=72)
# fig.autofmt_xdate() #(no fact)
# plt.subplots_adjust(bottom=0.1, right=0.8, top=0.9)
plt.subplots_adjust(left=0.05, bottom=0.08, right=0.95, top=0.95, wspace=0.15, hspace=0.25)
# set (gca,'Position',[0,0,512,512])
# fig.set_size_inches(18.5, 10.5)
# fig=plt.fig(figsize=(14,8))
ax1 = fig.add_subplot(321)
# asset=asset.apply(lambda x:round( x/asset[:1],2))
ax1.plot(asset)
# ax1.plot(asset1,'-r', linewidth=2)
ticks = ax1.get_xticks()
# start, end = ax1.get_xlim()
# print start, end, len(asset)
# print ticks, ticks[:-1]
# (ticks[:-1] if len(asset) > end else np.append(ticks[:-1], len(asset) - 1))
ax1.set_xticklabels([dates[i] for i in (np.append(ticks[:-1], len(asset) - 1))],
rotation=15) # Label x-axis with dates
# 拟合
X = np.arange(len(asset))
x = sm.add_constant(X)
model = regression.linear_model.OLS(asset, x).fit()
a = model.params[0]
b = model.params[1]
# log.info("a:%s b:%s" % (a, b))
log.info("X:%s a:%s b:%s" % (len(asset), a, b))
Y_hat = X * b + a
# 真实值-拟合值，差值最大最小作为价值波动区间
# 向下平移
i = (asset.values.T - Y_hat).argmin()
c_low = X[i] * b + a - asset.values[i]
Y_hatlow = X * b + a - c_low
# 向上平移
i = (asset.values.T - Y_hat).argmax()
c_high = X[i] * b + a - asset.values[i]
Y_hathigh = X * b + a - c_high
plt.plot(X, Y_hat, 'k', alpha=0.9);
plt.plot(X, Y_hatlow, 'r', alpha=0.9);
plt.plot(X, Y_hathigh, 'r', alpha=0.9);
# plt.xlabel('Date', fontsize=12)
plt.ylabel('Price', fontsize=12)
plt.title(code + " | " + str(dates[-1])[:11], fontsize=14)
plt.legend([asset.iat[-1]], fontsize=12, loc=4)
plt.grid(True)
# plt.legend([code]);
# plt.legend([code, 'Value center line', 'Value interval line']);
# fig=plt.fig()
# fig.figsize = [14,8]
scale = 1.1
zp = zoompan.ZoomPan()
figZoom = zp.zoom_factory(ax1, base_scale=scale)
figPan = zp.pan_factory(ax1)
ax2 = fig.add_subplot(323)
# ax2.plot(asset)
# ticks = ax2.get_xticks()
ax2.set_xticklabels([dates[i] for i in (np.append(ticks[:-1], len(asset) - 1))], rotation=15)
# plt.plot(X, Y_hat, 'k', alpha=0.9)
n = 5
d = (-c_high + c_low) / n
c = c_high
while c <= c_low:
Y = X * b + a - c
plt.plot(X, Y, 'r', alpha=0.9);
c = c + d
# asset=asset.apply(lambda x:round(x/asset[:1],2))
ax2.plot(asset)
# ax2.plot(asset1,'-r', linewidth=2)
# plt.xlabel('Date', fontsize=12)
plt.ylabel('Price', fontsize=12)
plt.grid(True)
# plt.title(code, fontsize=14)
# plt.legend([code])
# 将Y-Y_hat股价偏离中枢线的距离单画出一张图显示，对其边界线之间的区域进行均分，大于0的区间为高估，小于0的区间为低估，0为价值中枢线。
ax3 = fig.add_subplot(322)
# distance = (asset.values.T - Y_hat)
distance = (asset.values.T - Y_hat)[0]
if code.startswith('999') or code.startswith('399'):
ax3.plot(asset)
plt.plot(distance)
ticks = ax3.get_xticks()
ax3.set_xticklabels([dates[i] for i in (np.append(ticks[:-1], len(asset) - 1))], rotation=15)
n = 5
d = (-c_high + c_low) / n
c = c_high
while c <= c_low:
Y = X * b + a - c
plt.plot(X, Y - Y_hat, 'r', alpha=0.9);
c = c + d
ax3.plot(asset)
# plt.xlabel('Date', fontsize=12)
plt.ylabel('Price-center price', fontsize=14)
plt.grid(True)
else:
as3 = asset.apply(lambda x: round(x / asset[:1], 2))
ax3.plot(as3)
ax3.plot(asset1, '-r', linewidth=2)
plt.grid(True)
zp3 = zoompan.ZoomPan()
figZoom = zp3.zoom_factory(ax3, base_scale=scale)
figPan = zp3.pan_factory(ax3)
# plt.title(code, fontsize=14)
# plt.legend([code])
# 统计出每个区域内各股价的频数，得到直方图，为了更精细的显示各个区域的频数，这里将整个边界区间分成100份。
ax4 = fig.add_subplot(325)
log.info("assert:len:%s %s" % (len(asset.values.T - Y_hat), (asset.values.T - Y_hat)[0]))
# distance = map(lambda x:int(x),(asset.values.T - Y_hat)/Y_hat*100)
# now_distanse=int((asset.iat[-1]-Y_hat[-1])/Y_hat[-1]*100)
# log.debug("dis:%s now:%s"%(distance[:2],now_distanse))
# log.debug("now_distanse:%s"%now_distanse)
distance = (asset.values.T - Y_hat)
now_distanse = asset.iat[-1] - Y_hat[-1]
# distance = (asset.values.T-Y_hat)[0]
pd.Series(distance).plot(kind='hist', stacked=True, bins=100)
# plt.plot((asset.iat[-1].T-Y_hat),'b',alpha=0.9)
plt.axvline(now_distanse, hold=None, label="1", color='red')
# plt.axhline(now_distanse,hold=None,label="1",color='red')
# plt.axvline(asset.iat[0],hold=None,label="1",color='red',linestyle="--")
plt.xlabel('Undervalue ------------------------------------------> Overvalue', fontsize=12)
plt.ylabel('Frequency', fontsize=14)
# plt.title('Undervalue & Overvalue Statistical Chart', fontsize=14)
plt.legend([code, asset.iat[-1], str(dates[-1])[5:11]], fontsize=12)
plt.grid(True)
# plt.show()
# import os
# print(os.path.abspath(os.path.curdir))
ax5 = fig.add_subplot(326)
# fig.figsize=(5, 10)
log.info("assert:len:%s %s" % (len(asset.values.T - Y_hat), (asset.values.T - Y_hat)[0]))
# distance = map(lambda x:int(x),(asset.values.T - Y_hat)/Y_hat*100)
distance = (asset.values.T - Y_hat) / Y_hat * 100
now_distanse = ((asset.iat[-1] - Y_hat[-1]) / Y_hat[-1] * 100)
log.debug("dis:%s now:%s" % (distance[:2], now_distanse))
log.debug("now_distanse:%s" % now_distanse)
# n, bins = np.histogram(distance, 50)
# print n, bins[:2]
pd.Series(distance).plot(kind='hist', stacked=True, bins=100)
# plt.plot((asset.iat[-1].T-Y_hat),'b',alpha=0.9)
plt.axvline(now_distanse, hold=None, label="1", color='red')
# plt.axhline(now_distanse,hold=None,label="1",color='red')
# plt.axvline(asset.iat[0],hold=None,label="1",color='red',linestyle="--")
plt.xlabel('Undervalue ------------------------------------------> Overvalue', fontsize=14)
plt.ylabel('Frequency', fontsize=12)
# plt.title('Undervalue & Overvalue Statistical Chart', fontsize=14)
plt.legend([code, asset.iat[-1]], fontsize=12)
plt.grid(True)
ax6 = fig.add_subplot(324)
h = df.loc[:, ['open', 'close', 'high', 'low']]
highp = h['high'].values
lowp = h['low'].values
openp = h['open'].values
closep = h['close'].values
lr = LinearRegression()
x = np.atleast_2d(np.linspace(0, len(closep), len(closep))).T
lr.fit(x, closep)
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)
xt = np.atleast_2d(np.linspace(0, len(closep) + 200, len(closep) + 200)).T
yt = lr.predict(xt)
bV = []
bP = []
for i in range(1, len(highp) - 1):
if highp[i] <= highp[i - 1] and highp[i] < highp[i + 1] and lowp[i] <= lowp[i - 1] and lowp[i] < lowp[i + 1]:
bV.append(lowp[i])
bP.append(i)
d, p = LIS(bV)
idx = []
for i in range(len(p)):
idx.append(bP[p[i]])
lr = LinearRegression()
X = np.atleast_2d(np.array(idx)).T
Y = np.array(d)
lr.fit(X, Y)
estV = lr.predict(xt)
ax6.plot(closep, linewidth=2)
ax6.plot(idx, d, 'ko')
ax6.plot(xt, estV, '-r', linewidth=3)
ax6.plot(xt, yt, '-g', linewidth=3)
plt.grid(True)
# plt.tight_layout()
zp2 = zoompan.ZoomPan()
figZoom = zp2.zoom_factory(ax6, base_scale=scale)
figPan = zp2.pan_factory(ax6)
# plt.ion()
plt.show(block=False)
num_input = sys.argv[1]
args = parser.parse_args(num_input.split())
elif len(sys.argv) > 2:
num_input = sys.argv[1]
args = parser.parse_args(sys.argv[1:])
else:
parser.print_help()
while 1:
try:
if not len(num_input) == 6:
num_input = raw_input("please input code:")
if len(num_input) > 0:
args = parser.parse_args(num_input.split())
num_input = args.code
# print args.code,args.ptype,args.dtype,
start = cct.day8_to_day10(args.start)
end = cct.day8_to_day10(args.end)
# print start,end
if num_input == 'ex' or num_input == 'qu' \
or num_input == 'q' or num_input == "e":
sys.exit(0)
elif len(num_input) == 6:
code = args.code
# print code, args.ptype, args.dtype, start, end
get_linear_model_histogramDouble(code, args.ptype, args.dtype, start, end, args.vtype, args.filter)
# p=multiprocessing.Process(target=get_linear_model_histogramDouble,args=(code, args.ptype, args.dtype, start, end,args.vtype,args.filter,))
# p.daemon = True
# p.start()
# p.join()
# time.sleep(6)
num_input = ''
top_dif["diff"] = map(
lambda x, y: round((x - y) / y * 100, 1), top_dif["trade"].values, top_dif["lastp"].values
)
# print top_dif.loc['600610',:]
top_dif = top_dif[top_dif.low > 0]
top_dif = top_dif[top_dif.trade > 0]
# top_dif.loc['600610','volume':'lvol']
top_dif = top_dif[top_dif.lvol > 100000]
top_dif["volume"] = map(
lambda x, y: round(x / y / radio_t, 1), top_dif.volume.values, top_dif.lvol.values
)
# top_dif = top_dif[top_dif.volume < 100]
if filter == "y":
top_dif = top_dif[top_dif.date > cct.day8_to_day10(duration_date)]
log.info("dif1:%s" % len(top_dif))
log.info(top_dif[:1])
# top_dif = top_dif[top_dif.buy > top_dif.lastp]
# top_dif = top_dif[top_dif.buy > top_dif.lhigh]
# log.debug('dif2:%s' % len(top_dif))
# top_dif['volume'] = top_dif['volume'].apply(lambda x: round(x / radio_t, 1))
# log.debug("top_diff:vol")
# top_dif = top_dif[top_dif.volume > 1]
if len(top_dif) == 0:
print "No G,DataFrame is Empty!!!!!!"
log.debug("dif6 vol:%s" % (top_dif[:1].volume))
log.debug("dif6 vol>lvol:%s" % len(top_dif))
# top_dif = top_dif[top_dif.buy >= top_dif.open*0.99]
def get_duration_filter(code,
df=None,
dtype='d',
start=None,
end=None,
dl=None,
filter=True,
ptype='low',
power=True):
if start is not None and end is None and filter:
index_d = cct.day8_to_day10(start)
start = tdd.get_duration_price_date(code,
ptype=ptype,
dt=start,
df=df,
dl=dl,
power=power)
log.debug("start is not None start: %s index_d:%s" % (start, index_d))
elif end is not None and filter:
df = tdd.get_tdx_append_now_df_api(
code, start=start, end=end, df=df, dl=dl,
power=power).sort_index(ascending=True)
index_d = cct.day8_to_day10(start)
start = tdd.get_duration_price_date(code,
ptype=ptype,
dt=start,
df=df,
dl=dl,
power=power)
df = df[df.index >= start]
if len(df) > 2 and dl is None:
if df.index.values[0] < index_d:
df = df[df.index >= index_d]
if dl is not None:
if power:
start, index_d, df = tdd.get_duration_price_date(code,
ptype=ptype,
dl=dl,
filter=False,
df=df,
power=True)
else:
start, index_d = tdd.get_duration_price_date(code,
ptype=ptype,
dl=dl,
filter=False,
df=df,
power=False)
log.debug("dl not None code:%s start: %s index_d:%s" %
(code, start, index_d))
if len(df) > 0 and df is not None:
df = df.sort_index(ascending=True)
df = df[df.index >= start]
if len(df) == 0 or df is None:
if start is not None and len(start) > 8 and int(start[:4]) > 2500:
log.warn("code:%s ERROR:%s" % (code, start))
start = '2016-01-01'
df = tdd.get_tdx_append_now_df_api(code, start,
end).sort_index(ascending=True)
if start is None:
start = df.index.values[0]
if len(df) > 2 and dl is None and start is not None and filter:
if df.index.values[0] < index_d:
df = df[df.index >= index_d]
if not dtype == 'd':
df = tdd.get_tdx_stock_period_to_type(df,
dtype).sort_index(ascending=True)
return df
def get_linear_model_status(code,
df=None,
dtype='d',
type='m',
start=None,
end=None,
days=1,
filter='n',
dl=None,
countall=True,
ptype='low',
power=True):
if start is not None and end is None and filter == 'y':
index_d = cct.day8_to_day10(start)
start = tdd.get_duration_price_date(code,
ptype=ptype,
dt=start,
df=df,
dl=dl,
power=power)
log.debug("start is not None start: %s index_d:%s" % (start, index_d))
elif end is not None and filter == 'y':
df = tdd.get_tdx_append_now_df_api(
code, start=start, end=end, df=df, dl=dl,
power=power).sort_index(ascending=True)
index_d = cct.day8_to_day10(start)
start = tdd.get_duration_price_date(code,
ptype=ptype,
dt=start,
df=df,
dl=dl,
power=power)
df = df[df.index >= start]
if len(df) > 2 and dl is None:
if df.index.values[0] < index_d:
df = df[df.index >= index_d]
if dl is not None:
if power:
start, index_d, df = tdd.get_duration_price_date(code,
ptype=ptype,
dl=dl,
filter=False,
df=df,
power=power)
else:
start, index_d = tdd.get_duration_price_date(code,
ptype=ptype,
dl=dl,
filter=False,
df=df,
power=power)
log.debug("dl not None code:%s start: %s index_d:%s" %
(code, start, index_d))
if len(df) > 0 and df is not None:
df = df.sort_index(ascending=True)
df = df[df.index >= start]
if len(df) == 0 or df is None:
if start is not None and len(start) > 8 and int(start[:4]) > 2500:
log.warn("code:%s ERROR:%s" % (code, start))
start = '2016-01-01'
df = tdd.get_tdx_append_now_df_api(code, start,
end).sort_index(ascending=True)
if start is None:
start = df.index.values[0]
if len(df) > 2 and dl is None and start is not None and filter == 'y':
if df.index.values[0] < index_d:
df = df[df.index >= index_d]
if not dtype == 'd':
df = tdd.get_tdx_stock_period_to_type(df,
dtype).sort_index(ascending=True)
df = df.fillna(0)
if len(df) > 1 + days:
if days != 0:
asset = df[:-days]
else:
asset = df
else:
asset = df
if len(asset) > 1:
operationcount = 0
# ratio_l = []
if countall:
assetratio = asset
nowpratio = df['close'][-days] if len(df) > 1 + days else None
# print assetratio
op, ratio_l, status, sdl = get_linear_model_rule(code,
df=assetratio,
nowP=nowpratio,
ptype=ptype)
# print op,ratio,status,sdl
# ratio_l.append(round(ratio, 2))
operationcount += op
else:
assetratio = asset
nowpratio = df['close'][-days] if len(df) > 1 + days else None
op, ratio_l, status, sdl = get_linear_model_rule(code,
df=assetratio,
nowP=nowpratio,
ptype=ptype)
# ratio_l.append(round(ratio, 2))
operationcount += op
return operationcount, (ratio_l), df[:1].index.values[0], [
len(df), df[:1]
]
elif len(asset) == 1:
## log.error("powerCompute code:%s"%(code))
if ptype == 'high':
if df.close[-1] >= df.high[-1] * 0.99 and df.close[-1] >= df.open[
-1]:
return 12, 0, df.index.values[0], [len(df), df[:1]]
elif df.close[-1] > df.open[-1]:
if df.close[-1] > df.high[-1] * 0.97:
if len(df) > 2 and df.close[-1] > df.close[-2]:
return 10, 0, df.index.values[0], [len(df), df[:1]]
else:
return 11, 0, df.index.values[0], [len(df), df[:1]]
else:
return 9, 0, df.index.values[0], [len(df), df[:1]]
else:
if len(df) >= 2:
if df.close[-1] > df.close[-2] * 1.01:
return 9, 0, df.index.values[0], [len(df), df[:1]]
elif df.close[-1] > df.close[-2]:
return 8, 0, df.index.values[0], [len(df), df[:1]]
elif df.low[-1] > df.low[-2]:
return 6, 0, df.index.values[0], [len(df), df[:1]]
else:
return 3, 0, df.index.values[0], [len(df), df[:1]]
else:
return 1, 0, df.index.values[0], [len(df), df[:1]]
else:
return -10, 0, df.index.values[0], [len(df), df[:1]]
else:
if ptype == 'high':
return 13, 1, cct.get_today(), [len(df), df[:1]]
else:
return -10, -10, cct.get_today(), [len(df), df[:1]]
def get_linear_model_status(code, ptype="f", df=None, dtype="d", type="m", start=None, end=None, days=1, filter="y"):
if start is not None and filter == "y":
if code not in ["999999", "399006", "399001"]:
index_d, dl = tdd.get_duration_Index_date(dt=start)
log.debug("index_d:%s dl:%s" % (str(index_d), dl))
else:
index_d = cct.day8_to_day10(start)
log.debug("index_d:%s" % (index_d))
start = tdd.get_duration_price_date(code, ptype="low", dt=index_d)
log.debug("start: %s" % (start))
if df is None:
# df = tdd.get_tdx_append_now_df(code,ptype, start, end).sort_index(ascending=True)
df = tdd.get_tdx_append_now_df_api(code, ptype, start, end).sort_index(ascending=True)
log.info("Code:%s start:%s end:%s" % (code, start, df[-1:].index.values[0]))
if not dtype == "d":
df = tdd.get_tdx_stock_period_to_type(df, dtype).sort_index(ascending=True)
# df = tdd.get_tdx_Exp_day_to_df(code, 'f').sort_index(ascending=True)
def get_linear_model_ratio(asset):
log.info("asset:%s" % asset[-1:])
duration = asset[-1:].index.values[0]
log.debug("duration:%s" % duration)
log.debug("duration:%s" % cct.get_today_duration(duration))
# log.debug("duration:%s"%cct.get_duration_date(duration))
asset = asset.dropna()
X = np.arange(len(asset))
x = sm.add_constant(X)
model = regression.linear_model.OLS(asset, x).fit()
a = model.params[0]
b = model.params[1]
log.info("X:%s a:%0.1f b:%0.1f" % (len(asset), a, b))
Y = np.append(X, X[-1] + int(days))
log.debug("X:%s Y:%s" % (X[-1], Y[-1]))
# print ("X:%s" % (X[-1]))
Y_hat = X * b + a
# Y_hat_t = Y * b + a
# log.info("Y_hat:%s " % (Y_hat))
# log.info("asset:%s " % (asset.values))
ratio = b / a * 100
operation = 0
if Y_hat[-1] > Y_hat[1]:
log.debug("u-Y_hat[-1]:%0.1f" % (Y_hat[-1]))
log.debug("price:%0.1f" % asset.iat[-1])
log.debug("u:%0.1f" % Y_hat[1])
log.debug("price:%0.1f" % asset.iat[1])
if type.upper() == "M":
Y_Future = Y * b + a
# ratio = b/a*100
log.info("ratio: %0.1f %0.1f Y_Mid: %0.1f" % (b, ratio, Y_Future[-1]))
# diff = asset.iat[-1] - Y_hat[-1]
# if diff > 0:
# return True, len(asset), diff
# else:
# return False, len(asset), diff
elif type.upper() == "L":
i = (asset.values.T - Y_hat).argmin()
c_low = X[i] * b + a - asset.values[i]
# Y_hatlow = X * b + a - c_low
Y_Future = Y * b + a - c_low
log.info("b: %0.1f ratio:%0.1f Y_Mid: %0.1f" % (b, ratio, Y_Future[-1]))
# diff = asset.iat[-1] - Y_hatlow[-1]
# if asset.iat[-1] - Y_hatlow[-1] > 0:
# return True, len(asset), diff
# else:
# return False, len(asset), diff
elif type.upper() == "H":
i = (asset.values.T - Y_hat).argmax()
c_high = X[i] * b + a - asset.values[i]
# Y_hathigh = X * b + a - c_high
Y_Future = Y * b + a - c_high
log.info("ratio: %0.1f %0.1f Y_Mid: %0.1f" % (b, ratio, Y_Future[-1]))
diff = asset[-1] - Y_Future[-1]
# print ("as:%s Y:%s"%(asset[-1] ,Y_Future[-1]))
if diff > 0:
operation += 1
log.info("UP !!%s Y_Future: %0.1f b:%0.1f ratio:%0.1f " % (type.upper(), Y_Future[-1], b, ratio))
else:
log.info("Down %s Y_Future: %0.1f b:%0.1f ratio:%0.1f" % (type.upper(), Y_Future[-1], b, ratio))
return operation, ratio
else:
log.debug("down !!! d:%s" % Y_hat[1])
print ("down !!! d:%s" % Y_hat[1])
return 0, 0
# print "high:",
operationcount = 0
ratio_l = []
for co in ["high", "close", "low"]:
op, ratio = get_linear_model_ratio(df[co])
ratio_l.append(round(ratio, 2))
operationcount += op
log.info("op:%s min:%s ratio_l:%s" % (operationcount, min(ratio_l), ratio_l))
return operationcount, ratio.min()
