def getMAMid(MA_Short, MA_Mid, symbol, K_MIN, indexoffset=0):
#计算ma以及ma_cross
bardata = pd.read_csv(DC.BAR_DATA_PATH + symbol + '\\' + symbol + ' ' +
str(K_MIN) + '.csv')
madf = pd.DataFrame({'close': bardata.close})
madf['utc_time'] = bardata['utc_time']
madf['strtime'] = bardata['strtime']
madf['index'] = bardata['Unnamed: 0'] - indexoffset
#madf['MA_Short'] = MA.calMA(madf['close'], MA_Short)
madf['MA_Mid'] = MA.calMA(madf['close'], MA_Mid)
madf['MA_True'], madf['MA_Cross'] = MA.dfCross(madf, 'close', 'MA_Mid')
#madf.to_csv("mamid.csv")
return madf
def IntradayFryWin(symbolinfo, rawdata, paraSet):
setname = paraSet['Setname']
MACD_S = paraSet['MACD_S']
MACD_L = paraSet['MACD_L']
MACD_M = paraSet['MACD_M']
MA_N = paraSet['MA_N']
# print setname
rawdata['Unnamed: 0'] = range(rawdata.shape[0])
#beginindex = rawdata.ix[0, 'Unnamed: 0']
# 计算MACD
macd = MA.calMACD(rawdata['close'], MACD_S, MACD_L, MACD_M)
rawdata['DIF'] = macd[0]
rawdata['DEA'] = macd[1]
rawdata['MA'] = MA.calEMA(rawdata['close'], MA_N)
# 计算MACD的金叉和死叉
rawdata['MACD_True'], rawdata['MACD_Cross'] = MA.dfCross(rawdata, 'DIF', 'DEA')
# ================================ 找出买卖点================================================
# 1.先找出SAR金叉的买卖点
# 2.找到结合判决条件的买点
# 3.从MA买点中滤出真实买卖点
# 取出金叉点
goldcrosslist = pd.DataFrame({'goldcrosstime': rawdata.loc[rawdata['MACD_Cross'] == 1, 'strtime']})
goldcrosslist['goldcrossutc'] = rawdata.loc[rawdata['MACD_Cross'] == 1, 'utc_time']
goldcrosslist['goldcrossindex'] = rawdata.loc[rawdata['MACD_Cross'] == 1, 'Unnamed: 0']
goldcrosslist['goldcrossprice'] = rawdata.loc[rawdata['MACD_Cross'] == 1, 'close']
# 取出死叉点
deathcrosslist = pd.DataFrame({'deathcrosstime': rawdata.loc[rawdata['MACD_Cross'] == -1, 'strtime']})
deathcrosslist['deathcrossutc'] = rawdata.loc[rawdata['MACD_Cross'] == -1, 'utc_time']
deathcrosslist['deathcrossindex'] = rawdata.loc[rawdata['MACD_Cross'] == -1, 'Unnamed: 0']
deathcrosslist['deathcrossprice'] = rawdata.loc[rawdata['MACD_Cross'] == -1, 'close']
goldcrosslist = goldcrosslist.reset_index(drop=True)
deathcrosslist = deathcrosslist.reset_index(drop=True)
# 生成多仓序列（金叉在前，死叉在后）
if goldcrosslist.ix[0, 'goldcrossindex'] < deathcrosslist.ix[0, 'deathcrossindex']:
longcrosslist = pd.concat([goldcrosslist, deathcrosslist], axis=1)
else: # 如果第一个死叉的序号在金叉前，则要将死叉往上移1格
longcrosslist = pd.concat([goldcrosslist, deathcrosslist.shift(-1).fillna(0)], axis=1)
longcrosslist = longcrosslist.set_index(pd.Index(longcrosslist['goldcrossindex']), drop=True)
# 生成空仓序列（死叉在前，金叉在后）
if deathcrosslist.ix[0, 'deathcrossindex'] < goldcrosslist.ix[0, 'goldcrossindex']:
shortcrosslist = pd.concat([deathcrosslist, goldcrosslist], axis=1)
else: # 如果第一个金叉的序号在死叉前，则要将金叉往上移1格
shortcrosslist = pd.concat([deathcrosslist, goldcrosslist.shift(-1).fillna(0)], axis=1)
shortcrosslist = shortcrosslist.set_index(pd.Index(shortcrosslist['deathcrossindex']), drop=True)
# 取出开多序号和开空序号
openlongindex = rawdata.loc[
(rawdata['MACD_Cross'] == 1) & (rawdata['close'] > rawdata['MA']) & (rawdata['ATR'] > 6)].index
openshortindex = rawdata.loc[
(rawdata['MACD_Cross'] == -1) & (rawdata['close'] < rawdata['MA']) & (rawdata['ATR'] > 6)].index
# 从多仓序列中取出开多序号的内容，即为开多操作
longopr = longcrosslist.loc[openlongindex]
longopr['tradetype'] = 1
longopr.rename(columns={'goldcrosstime': 'opentime',
'goldcrossutc': 'openutc',
'goldcrossindex': 'openindex',
'goldcrossprice': 'openprice',
'deathcrosstime': 'closetime',
'deathcrossutc': 'closeutc',
'deathcrossindex': 'closeindex',
'deathcrossprice': 'closeprice'}, inplace=True)
# 从空仓序列中取出开空序号的内容，即为开空操作
shortopr = shortcrosslist.loc[openshortindex]
shortopr['tradetype'] = -1
shortopr.rename(columns={'deathcrosstime': 'opentime',
'deathcrossutc': 'openutc',
'deathcrossindex': 'openindex',
'deathcrossprice': 'openprice',
'goldcrosstime': 'closetime',
'goldcrossutc': 'closeutc',
'goldcrossindex': 'closeindex',
'goldcrossprice': 'closeprice'}, inplace=True)
# 结果分析
result = pd.concat([longopr, shortopr])
result = result.sort_index()
result = result.reset_index(drop=True)
# result.drop(result.shape[0] - 1, inplace=True)
result = result.dropna()
# 去掉跨合约的操作
# 使用单合约，不用再去掉跨合约
# result = removeContractSwap(result, contractswaplist)
slip = symbolinfo.getSlip()
result['ret'] = ((result['closeprice'] - result['openprice']) * result['tradetype']) - slip
result['ret_r'] = result['ret'] / result['openprice']
results = {}
'''
# 使用单合约，策略核心内不再计算结果
if calcResult:
result['commission_fee'], result['per earn'], result['own cash'], result['hands'] = RS.calcResult(result,
symbolinfo,
initialCash,
positionRatio)
endcash = result['own cash'].iloc[-1]
Annual = RS.annual_return(result)
Sharpe = RS.sharpe_ratio(result)
DrawBack = RS.max_drawback(result)[0]
SR = RS.success_rate(result)
max_single_loss_rate = abs(result['ret_r'].min())
results = {
'Setname':setname,
'opentimes': result.shape[0],
'end_cash': endcash,
'SR': SR,
'Annual': Annual,
'Sharpe': Sharpe,
'DrawBack': DrawBack,
'max_single_loss_rate': max_single_loss_rate
}
closeopr = result.loc[:, 'closetime':'tradetype']
return result, rawdata, closeopr, results
'''
return result
def HullRsiTunnelWin(symbolinfo, rawdata, para_set):
setname = para_set['Setname']
para_n1 = para_set['N1']
para_m1 = para_set['M1']
para_m2 = para_set['M2']
para_n = para_set['N']
para_tunnel_n = para_set['Tunnel_N']
#para_rsi1_up = para_set['RSI1_UP']
#para_rsi1_down = para_set['RSI1_DOWN']
# print setname
"""
LC := REF(CLOSE,1);
BACKGROUNDSTYLE(1);
RSI1:SMA(MAX(CLOSE-LC,0),N1,1)/SMA(ABS(CLOSE-LC),N1,1)*100;
RMA1:EMA(RSI1,M1);
RMA2:EMA(RMA1,M2);
RSINEW:=RMA1-RMA2;
X:= 2*EMA2(RSINEW,ROUND(N/2,0))-EMA2(RSINEW,N);
HURSI:10*EMA2(X,ROUND(SQRT(N),0)),COLORSTICK;
"""
rsi1 = pd.Series(RSI.rsi(rawdata['close'], para_n1))
rsi_ema1 = MA.calEMA(rsi1, para_m1)
rsi_ema2 = MA.calEMA(rsi_ema1, para_m2)
rsi_new = rsi_ema1 - rsi_ema2
hull_rsi = MA.hull_ma(rsi_new, para_n)
#rawdata['RSI1'] = rsi1
rawdata['RSI_EMA1'] = rsi_ema1
#rawdata['RSI_EMA2'] = rsi_ema2
#rawdata['RSI_NEW'] = rsi_new
rawdata['HullRsi'] = hull_rsi
rawdata['TOP_EMA'] = MA.calEMA(rawdata['high'], para_tunnel_n)
rawdata['BOTTOM_EMA'] = MA.calEMA(rawdata['low'], para_tunnel_n)
rawdata['zero'] = 0
rawdata['Unnamed: 0'] = range(rawdata.shape[0])
# 计算M金叉和死叉
rawdata['HullRsi_True'], rawdata['HullRsi_Cross'] = MA.dfCross(
rawdata, 'HullRsi', 'zero')
# ================================ 找出买卖点================================================
# 1.先找出SAR金叉的买卖点
# 2.找到结合判决条件的买点
# 3.从MA买点中滤出真实买卖点
# 取出金叉点
goldcrosslist = pd.DataFrame({
'goldcrosstime':
rawdata.loc[rawdata['HullRsi_Cross'] == 1, 'strtime']
})
goldcrosslist['goldcrossutc'] = rawdata.loc[rawdata['HullRsi_Cross'] == 1,
'utc_time']
goldcrosslist['goldcrossindex'] = rawdata.loc[rawdata['HullRsi_Cross'] ==
1, 'Unnamed: 0']
goldcrosslist['goldcrossprice'] = rawdata.loc[rawdata['HullRsi_Cross'] ==
1, 'close']
goldcrosslist['goldcrossrsi'] = rawdata.loc[rawdata['HullRsi_Cross'] == 1,
'RSI_EMA1']
# 取出死叉点
deathcrosslist = pd.DataFrame({
'deathcrosstime':
rawdata.loc[rawdata['HullRsi_Cross'] == -1, 'strtime']
})
deathcrosslist['deathcrossutc'] = rawdata.loc[rawdata['HullRsi_Cross'] ==
-1, 'utc_time']
deathcrosslist['deathcrossindex'] = rawdata.loc[rawdata['HullRsi_Cross'] ==
-1, 'Unnamed: 0']
deathcrosslist['deathcrossprice'] = rawdata.loc[rawdata['HullRsi_Cross'] ==
-1, 'close']
deathcrosslist['deathcrossrsi'] = rawdata.loc[rawdata['HullRsi_Cross'] ==
-1, 'RSI_EMA1']
goldcrosslist = goldcrosslist.reset_index(drop=True)
deathcrosslist = deathcrosslist.reset_index(drop=True)
# 生成多仓序列（金叉在前，死叉在后）
if goldcrosslist.ix[0, 'goldcrossindex'] < deathcrosslist.ix[
0, 'deathcrossindex']:
longcrosslist = pd.concat([goldcrosslist, deathcrosslist], axis=1)
else: # 如果第一个死叉的序号在金叉前，则要将死叉往上移1格
longcrosslist = pd.concat(
[goldcrosslist, deathcrosslist.shift(-1)], axis=1)
longcrosslist = longcrosslist.set_index(pd.Index(
longcrosslist['goldcrossindex']),
drop=True)
# 生成空仓序列（死叉在前，金叉在后）
if deathcrosslist.ix[0, 'deathcrossindex'] < goldcrosslist.ix[
0, 'goldcrossindex']:
shortcrosslist = pd.concat([deathcrosslist, goldcrosslist], axis=1)
else: # 如果第一个金叉的序号在死叉前，则要将金叉往上移1格
shortcrosslist = pd.concat(
[deathcrosslist, goldcrosslist.shift(-1)], axis=1)
shortcrosslist = shortcrosslist.set_index(pd.Index(
shortcrosslist['deathcrossindex']),
drop=True)
# 取出开多序号和开空序号
#openlongindex = rawdata.loc[
# (rawdata['HullRsi_Cross'] == 1) & (rawdata['RSI_EMA1'] < para_rsi1_up)].index
#openshortindex = rawdata.loc[
# (rawdata['HullRsi_Cross'] == -1) & (rawdata['RSI_EMA1'] > para_rsi1_down)].index
openlongindex = rawdata.loc[(rawdata['HullRsi_Cross'] == 1) &
(rawdata['close'] > rawdata['TOP_EMA'])].index
openshortindex = rawdata.loc[(rawdata['HullRsi_Cross'] == -1) & (
rawdata['close'] < rawdata['BOTTOM_EMA'])].index
# 从多仓序列中取出开多序号的内容，即为开多操作
longopr = longcrosslist.loc[openlongindex]
longopr['tradetype'] = 1
longopr.rename(columns={
'goldcrosstime': 'opentime',
'goldcrossutc': 'openutc',
'goldcrossindex': 'openindex',
'goldcrossprice': 'openprice',
'goldcrossrsi': 'open_rsi',
'deathcrosstime': 'closetime',
'deathcrossutc': 'closeutc',
'deathcrossindex': 'closeindex',
'deathcrossprice': 'closeprice',
'deathcrossrsi': 'close_rsi'
},
inplace=True)
# 从空仓序列中取出开空序号的内容，即为开空操作
shortopr = shortcrosslist.loc[openshortindex]
shortopr['tradetype'] = -1
shortopr.rename(columns={
'deathcrosstime': 'opentime',
'deathcrossutc': 'openutc',
'deathcrossindex': 'openindex',
'deathcrossprice': 'openprice',
'deathcrossrsi': 'open_rsi',
'goldcrosstime': 'closetime',
'goldcrossutc': 'closeutc',
'goldcrossindex': 'closeindex',
'goldcrossprice': 'closeprice',
'goldcrossrsi': 'close_rsi'
},
inplace=True)
# 结果分析
result = pd.concat([longopr, shortopr])
result = result.sort_index()
result = result.reset_index(drop=True)
# result.drop(result.shape[0] - 1, inplace=True)
result = result.dropna()
# 去掉跨合约的操作
# 使用单合约，不用再去掉跨合约
# result = removeContractSwap(result, contractswaplist)
#rawdata.to_csv('%s_rawdata.csv' % setname)
slip = symbolinfo.getSlip()
result['ret'] = ((result['closeprice'] - result['openprice']) *
result['tradetype']) - slip
result['ret_r'] = result['ret'] / result['openprice']
return result
def MacdBiasWin(symbolinfo, rawdata_macd, macdParaSet):
setname = macdParaSet['Setname']
MACD_S = macdParaSet['MACD_S']
MACD_L = macdParaSet['MACD_L']
MACD_M = macdParaSet['MACD_M']
BIAS_N = macdParaSet['BIAS_N']
BIAS_UP = macdParaSet['BIAS_UP']
BIAS_DOWN = macdParaSet['BIAS_DOWN']
rawdata_macd['Unnamed: 0'] = range(rawdata_macd.shape[0])
# 计算MACD
#macd = MA.calMACD(rawdata_macd['close'], MACD_S, MACD_L, MACD_M) # 普通MACD
macd = MA.hull_macd(rawdata_macd['close'], MACD_S, MACD_L,
MACD_M) # hull_macd
rawdata_macd['DIF'] = macd[0]
rawdata_macd['DEA'] = macd[1]
rawdata_macd['BIAS'] = bias(rawdata_macd['close'], BIAS_N)
# 计算MACD的金叉和死叉
rawdata_macd['MACD_True'], rawdata_macd['MACD_Cross'] = MA.dfCross(
rawdata_macd, 'DIF', 'DEA')
# ================================ 找出买卖点================================================
# 1.先找出SAR金叉的买卖点
# 2.找到结合判决条件的买点
# 3.从MA买点中滤出真实买卖点
# 取出金叉点
goldcrosslist = pd.DataFrame({
'goldcrosstime':
rawdata_macd.loc[rawdata_macd['MACD_Cross'] == 1, 'strtime']
})
goldcrosslist['goldcrossutc'] = rawdata_macd.loc[
rawdata_macd['MACD_Cross'] == 1, 'utc_time']
goldcrosslist['goldcrossindex'] = rawdata_macd.loc[
rawdata_macd['MACD_Cross'] == 1, 'Unnamed: 0']
goldcrosslist['goldcrossprice'] = rawdata_macd.loc[
rawdata_macd['MACD_Cross'] == 1, 'close']
# 取出死叉点
deathcrosslist = pd.DataFrame({
'deathcrosstime':
rawdata_macd.loc[rawdata_macd['MACD_Cross'] == -1, 'strtime']
})
deathcrosslist['deathcrossutc'] = rawdata_macd.loc[
rawdata_macd['MACD_Cross'] == -1, 'utc_time']
deathcrosslist['deathcrossindex'] = rawdata_macd.loc[
rawdata_macd['MACD_Cross'] == -1, 'Unnamed: 0']
deathcrosslist['deathcrossprice'] = rawdata_macd.loc[
rawdata_macd['MACD_Cross'] == -1, 'close']
goldcrosslist = goldcrosslist.reset_index(drop=True)
deathcrosslist = deathcrosslist.reset_index(drop=True)
# 生成多仓序列（金叉在前，死叉在后）
if goldcrosslist.ix[0, 'goldcrossindex'] < deathcrosslist.ix[
0, 'deathcrossindex']:
longcrosslist = pd.concat([goldcrosslist, deathcrosslist], axis=1)
else: # 如果第一个死叉的序号在金叉前，则要将死叉往上移1格
longcrosslist = pd.concat(
[goldcrosslist, deathcrosslist.shift(-1)], axis=1)
longcrosslist = longcrosslist.set_index(pd.Index(
longcrosslist['goldcrossindex']),
drop=True)
# 生成空仓序列（死叉在前，金叉在后）
if deathcrosslist.ix[0, 'deathcrossindex'] < goldcrosslist.ix[
0, 'goldcrossindex']:
shortcrosslist = pd.concat([deathcrosslist, goldcrosslist], axis=1)
else: # 如果第一个金叉的序号在死叉前，则要将金叉往上移1格
shortcrosslist = pd.concat(
[deathcrosslist, goldcrosslist.shift(-1)], axis=1)
shortcrosslist = shortcrosslist.set_index(pd.Index(
shortcrosslist['deathcrossindex']),
drop=True)
# 取出开多序号和开空序号
openlongindex = rawdata_macd.loc[(rawdata_macd['MACD_Cross'] == 1) &
(rawdata_macd['BIAS'] < BIAS_DOWN)].index
openshortindex = rawdata_macd.loc[(rawdata_macd['MACD_Cross'] == -1)
& (rawdata_macd['BIAS'] > BIAS_UP)].index
# 从多仓序列中取出开多序号的内容，即为开多操作
longopr = longcrosslist.loc[openlongindex]
longopr['tradetype'] = 1
longopr.rename(columns={
'goldcrosstime': 'opentime',
'goldcrossutc': 'openutc',
'goldcrossindex': 'openindex',
'goldcrossprice': 'openprice',
'deathcrosstime': 'closetime',
'deathcrossutc': 'closeutc',
'deathcrossindex': 'closeindex',
'deathcrossprice': 'closeprice'
},
inplace=True)
# 从空仓序列中取出开空序号的内容，即为开空操作
shortopr = shortcrosslist.loc[openshortindex]
shortopr['tradetype'] = -1
shortopr.rename(columns={
'deathcrosstime': 'opentime',
'deathcrossutc': 'openutc',
'deathcrossindex': 'openindex',
'deathcrossprice': 'openprice',
'goldcrosstime': 'closetime',
'goldcrossutc': 'closeutc',
'goldcrossindex': 'closeindex',
'goldcrossprice': 'closeprice'
},
inplace=True)
# 结果分析
result = pd.concat([longopr, shortopr])
result = result.sort_index()
result = result.reset_index(drop=True)
result = result.dropna()
slip = symbolinfo.getSlip()
result['ret'] = ((result['closeprice'] - result['openprice']) *
result['tradetype']) - slip
result['ret_r'] = result['ret'] / result['openprice']
return result
def Lvyi3MAWin(symbolinfo, rawdata, paraset):
setname = paraset['Setname']
MA_Short = paraset['MA_Short']
MA_Mid = paraset['MA_Mid']
MA_Long = paraset['MA_Long']
rawdata['Unnamed: 0'] = range(rawdata.shape[0])
beginindex = rawdata.ix[0, 'Unnamed: 0']
#df_MA = MA.MA(rawdata['close'], MA_Short, MA_Mid)
#df_MA.drop('close', axis=1, inplace=True)
#df = pd.concat([rawdata, df_MA], axis=1)
df = rawdata
df['MA_Short'] = MA.calMA(df['close'],MA_Short)
df['MA_Mid'] = MA.calMA(df['close'],MA_Mid)
df['MA_Long'] = MA.calMA(df['close'],MA_Long)
df['MA_True'],df['MA_Cross'] = MA.dfCross(df,'MA_Short','MA_Mid')
# 找出买卖点：
# 1.先找出MA金叉的买卖点
# 2.找到结合判决条件的买点
# 3.从MA买点中滤出真实买卖点
# 取出金叉点
goldcrosslist = pd.DataFrame({'goldcrosstime': df.loc[df['MA_Cross'] == 1, 'strtime']})
goldcrosslist['goldcrossutc'] = df.loc[df['MA_Cross'] == 1, 'utc_time']
goldcrosslist['goldcrossindex'] = df.loc[df['MA_Cross'] == 1, 'Unnamed: 0'] - beginindex
goldcrosslist['goldcrossprice'] = df.loc[df['MA_Cross'] == 1, 'close']
# 取出死叉点
deathcrosslist = pd.DataFrame({'deathcrosstime': df.loc[df['MA_Cross'] == -1, 'strtime']})
deathcrosslist['deathcrossutc'] = df.loc[df['MA_Cross'] == -1, 'utc_time']
deathcrosslist['deathcrossindex'] = df.loc[df['MA_Cross'] == -1, 'Unnamed: 0'] - beginindex
deathcrosslist['deathcrossprice'] = df.loc[df['MA_Cross'] == -1, 'close']
goldcrosslist = goldcrosslist.reset_index(drop=True)
deathcrosslist = deathcrosslist.reset_index(drop=True)
# 生成多仓序列（金叉在前，死叉在后）
if goldcrosslist.ix[0, 'goldcrossindex'] < deathcrosslist.ix[0, 'deathcrossindex']:
longcrosslist = pd.concat([goldcrosslist, deathcrosslist], axis=1)
else: # 如果第一个死叉的序号在金叉前，则要将死叉往上移1格
longcrosslist = pd.concat([goldcrosslist, deathcrosslist.shift(-1)], axis=1)
longcrosslist = longcrosslist.set_index(pd.Index(longcrosslist['goldcrossindex']), drop=True)
# 生成空仓序列（死叉在前，金叉在后）
if deathcrosslist.ix[0, 'deathcrossindex'] < goldcrosslist.ix[0, 'goldcrossindex']:
shortcrosslist = pd.concat([deathcrosslist, goldcrosslist], axis=1)
else: # 如果第一个金叉的序号在死叉前，则要将金叉往上移1格
shortcrosslist = pd.concat([deathcrosslist, goldcrosslist.shift(-1)], axis=1)
shortcrosslist = shortcrosslist.set_index(pd.Index(shortcrosslist['deathcrossindex']), drop=True)
# 取出开多序号和开空序号
openlongindex = df.loc[(df['MA_Cross'] == 1) & (df['MA_Short'] >= df['MA_Long']) & (df['MA_Mid'] >= df['MA_Long'])].index
openshortindex = df.loc[(df['MA_Cross'] == -1) & (df['MA_Short'] <= df['MA_Long']) & (df['MA_Mid'] <= df['MA_Long'])].index
# 从多仓序列中取出开多序号的内容，即为开多操作
longopr = longcrosslist.loc[openlongindex]
longopr['tradetype'] = 1
longopr.rename(columns={'goldcrosstime': 'opentime',
'goldcrossutc': 'openutc',
'goldcrossindex': 'openindex',
'goldcrossprice': 'openprice',
'deathcrosstime': 'closetime',
'deathcrossutc': 'closeutc',
'deathcrossindex': 'closeindex',
'deathcrossprice': 'closeprice'}, inplace=True)
# 从空仓序列中取出开空序号的内容，即为开空操作
shortopr = shortcrosslist.loc[openshortindex]
shortopr['tradetype'] = -1
shortopr.rename(columns={'deathcrosstime': 'opentime',
'deathcrossutc': 'openutc',
'deathcrossindex': 'openindex',
'deathcrossprice': 'openprice',
'goldcrosstime': 'closetime',
'goldcrossutc': 'closeutc',
'goldcrossindex': 'closeindex',
'goldcrossprice': 'closeprice'}, inplace=True)
# 结果分析
result = pd.concat([longopr, shortopr])
result = result.sort_index()
result = result.reset_index(drop=True)
#result.drop(result.shape[0] - 1, inplace=True)
result = result.dropna()
# 去掉跨合约的操作
# 使用单合约，不用再去掉跨合约
#result = removeContractSwap(result, contractswaplist)
slip = symbolinfo.getSlip()
result['ret'] = ((result['closeprice'] - result['openprice']) * result['tradetype']) - slip
result['ret_r'] = result['ret'] / result['openprice']
results = {}
'''
# 使用单合约，策略核心内不再计算结果
if calcResult:
result['commission_fee'], result['per earn'], result['own cash'], result['hands'] = RS.calcResult(result,
symbolinfo,
initialCash,
positionRatio)
endcash = result['own cash'].iloc[-1]
Annual = RS.annual_return(result)
Sharpe = RS.sharpe_ratio(result)
DrawBack = RS.max_drawback(result)[0]
SR = RS.success_rate(result)
max_single_loss_rate = abs(result['ret_r'].min())
results = {
'Setname':setname,
'opentimes': result.shape[0],
'end_cash': endcash,
'SR': SR,
'Annual': Annual,
'Sharpe': Sharpe,
'DrawBack': DrawBack,
'max_single_loss_rate': max_single_loss_rate
}
closeopr = result.loc[:, 'closetime':'tradetype']
return result, df, closeopr, results
'''
return result
def HopeWin(symbolInfo,setname,K_MIN_SAR,K_MIN_MACD,bollFilter,startdate,enddate,macdParaSet,contractswaplist,calcResult=True):
print setname
rawdata_sar = pd.read_csv('rawdata_sar.csv')
rawdata_macd = DC.getBarData(symbolInfo.symbol, K_MIN_MACD, startdate + " 00:00:00", enddate + " 23:59:59")
MACD_S=macdParaSet['MACD_S']
MACD_L = macdParaSet['MACD_L']
MACD_M = macdParaSet['MACD_M']
'''
# 计算MACD
macd = MA.calMACD(rawdata_macd['close'], MACD_S, MACD_L, MACD_M)
rawdata_macd['DIF'] = macd[0]
rawdata_macd['DEA'] = macd[1]
# 将MACD合并到SAR数据
rawdata_sar.set_index('utc_time', inplace=True)
rawdata_macd.set_index('utc_endtime', inplace=True) #使用macd的结束时间跟SAR的开始时间对齐，相当于使用上1小时的MACD值
rawdata_sar['DIF'] = rawdata_macd['DIF']
rawdata_sar['DEA'] = rawdata_macd['DEA']
rawdata_sar.fillna(method='ffill', inplace=True)
rawdata_sar.reset_index(inplace=True)
'''
rawdata_sar=prepareMACD(rawdata_sar,rawdata_macd,MACD_S,MACD_L,MACD_M)
# 计算MACD的金叉和死叉
rawdata_sar['MACD_True'], rawdata_sar['MACD_Cross'] = MA.dfCross(rawdata_sar, 'DIF', 'DEA')
# ================================ 找出买卖点================================================
# 1.先找出SAR金叉的买卖点
# 2.找到结合判决条件的买点
# 3.从MA买点中滤出真实买卖点
# 取出金叉点
goldcrosslist = pd.DataFrame({'goldcrosstime': rawdata_sar.loc[rawdata_sar['SAR_R'] == 1, 'strtime']})
goldcrosslist['goldcrossutc'] = rawdata_sar.loc[rawdata_sar['SAR_R'] == 1, 'utc_time']
goldcrosslist['goldcrossindex'] = rawdata_sar.loc[rawdata_sar['SAR_R'] == 1, 'Unnamed: 0']
goldcrosslist['goldcrossprice'] = rawdata_sar.loc[rawdata_sar['SAR_R'] == 1, 'close']
# 取出死叉点
deathcrosslist = pd.DataFrame({'deathcrosstime': rawdata_sar.loc[rawdata_sar['SAR_R'] == -1, 'strtime']})
deathcrosslist['deathcrossutc'] = rawdata_sar.loc[rawdata_sar['SAR_R'] == -1, 'utc_time']
deathcrosslist['deathcrossindex'] = rawdata_sar.loc[rawdata_sar['SAR_R'] == -1, 'Unnamed: 0']
deathcrosslist['deathcrossprice'] = rawdata_sar.loc[rawdata_sar['SAR_R'] == -1, 'close']
goldcrosslist = goldcrosslist.reset_index(drop=True)
deathcrosslist = deathcrosslist.reset_index(drop=True)
# 生成多仓序列（金叉在前，死叉在后）
if goldcrosslist.ix[0, 'goldcrossindex'] < deathcrosslist.ix[0, 'deathcrossindex']:
longcrosslist = pd.concat([goldcrosslist, deathcrosslist], axis=1)
else: # 如果第一个死叉的序号在金叉前，则要将死叉往上移1格
longcrosslist = pd.concat([goldcrosslist, deathcrosslist.shift(-1).fillna(0)], axis=1)
longcrosslist = longcrosslist.set_index(pd.Index(longcrosslist['goldcrossindex']), drop=True)
# 生成空仓序列（死叉在前，金叉在后）
if deathcrosslist.ix[0, 'deathcrossindex'] < goldcrosslist.ix[0, 'goldcrossindex']:
shortcrosslist = pd.concat([deathcrosslist, goldcrosslist], axis=1)
else: # 如果第一个金叉的序号在死叉前，则要将金叉往上移1格
shortcrosslist = pd.concat([deathcrosslist, goldcrosslist.shift(-1).fillna(0)], axis=1)
shortcrosslist = shortcrosslist.set_index(pd.Index(shortcrosslist['deathcrossindex']), drop=True)
# 取出开多序号和开空序号
#SAR金叉做多，死叉做空
#做多过滤：MACD处于金叉期间且DIF>=0
#做空过滤：MACD处于死叉期间且DIF<0
if bollFilter:
openlongindex = rawdata_sar.loc[
(rawdata_sar['SAR_R'] == 1) & (rawdata_sar['MACD_True'] == 1) & (rawdata_sar['DIF'] >= 0) & (
rawdata_sar['boll_filter'] == 1)].index
openshortindex = rawdata_sar.loc[
(rawdata_sar['SAR_R'] == -1) & (rawdata_sar['MACD_True'] == -1) & (rawdata_sar['DIF'] < 0) & (
rawdata_sar['boll_filter'] == 1)].index
else:
openlongindex = rawdata_sar.loc[
(rawdata_sar['SAR_R'] == 1) & (rawdata_sar['MACD_True'] == 1) & (rawdata_sar['DIF'] >= 0) ].index
openshortindex = rawdata_sar.loc[
(rawdata_sar['SAR_R'] == -1) & (rawdata_sar['MACD_True'] == -1) & (rawdata_sar['DIF'] < 0)].index
# 从多仓序列中取出开多序号的内容，即为开多操作
longopr = longcrosslist.loc[openlongindex]
longopr['tradetype'] = 1
longopr.rename(columns={'goldcrosstime': 'opentime',
'goldcrossutc': 'openutc',
'goldcrossindex': 'openindex',
'goldcrossprice': 'openprice',
'deathcrosstime': 'closetime',
'deathcrossutc': 'closeutc',
'deathcrossindex': 'closeindex',
'deathcrossprice': 'closeprice'}, inplace=True)
# 从空仓序列中取出开空序号的内容，即为开空操作
shortopr = shortcrosslist.loc[openshortindex]
shortopr['tradetype'] = -1
shortopr.rename(columns={'deathcrosstime': 'opentime',
'deathcrossutc': 'openutc',
'deathcrossindex': 'openindex',
'deathcrossprice': 'openprice',
'goldcrosstime': 'closetime',
'goldcrossutc': 'closeutc',
'goldcrossindex': 'closeindex',
'goldcrossprice': 'closeprice'}, inplace=True)
# 结果分析
result = pd.concat([longopr, shortopr])
result = result.sort_index()
result = result.reset_index(drop=True)
result.drop(result.shape[0] - 1, inplace=True)
# 去掉跨合约的操作
result = removeContractSwap(result, contractswaplist)
initial_cash = 20000
margin_rate = 0.2
slip = symbolInfo.getSlip()
multiplier = symbolInfo.getMultiplier()
poundgeType, poundgeFee, poundgeRate = symbolInfo.getPoundage()
result['ret'] = ((result['closeprice'] - result['openprice']) * result['tradetype']) - slip
result['ret_r'] = result['ret'] / result['openprice']
results={}
if calcResult:
firsttradecash = initial_cash / margin_rate
result['commission_fee'] = 0
if poundgeType == symbolInfo.POUNDGE_TYPE_RATE:
result.ix[0, 'commission_fee'] = firsttradecash * poundgeRate * 2
else:
result.ix[0, 'commission_fee'] = firsttradecash / (multiplier * result.ix[0, 'openprice']) * poundgeFee * 2
result['per earn'] = 0 # 单笔盈亏
result['own cash'] = 0 # 自有资金线
result['trade money'] = 0 # 杠杆后的可交易资金线
result.ix[0, 'per earn'] = firsttradecash * result.ix[0, 'ret_r']
result.ix[0, 'own cash'] = initial_cash + result.ix[0, 'per earn'] - result.ix[0, 'commission_fee']
result.ix[0, 'trade money'] = result.ix[0, 'own cash'] / margin_rate
oprtimes = result.shape[0]
for i in np.arange(1, oprtimes):
# 根据手续费类型计算手续费
if poundgeType == symbolInfo.POUNDGE_TYPE_RATE:
commission = result.ix[i - 1, 'trade money'] * poundgeRate * 2
else:
commission = result.ix[i - 1, 'trade money'] / (multiplier * result.ix[i, 'openprice']) * poundgeFee * 2
perearn = result.ix[i - 1, 'trade money'] * result.ix[i, 'ret_r']
owncash = result.ix[i - 1, 'own cash'] + perearn - commission
result.ix[i, 'own cash'] = owncash
result.ix[i, 'commission_fee'] = commission
result.ix[i, 'per earn'] = perearn
result.ix[i, 'trade money'] = owncash / margin_rate
endcash = result.ix[oprtimes - 1, 'own cash']
Annual = RS.annual_return(result)
Sharpe = RS.sharpe_ratio(result)
DrawBack = RS.max_drawback(result)[0]
SR = RS.success_rate(result)
max_single_loss_rate = abs(result['ret_r'].min())
results = {
'Setname':setname,
'MACD_S':MACD_S,
'MACD_L':MACD_L,
'MACD_M':MACD_M,
'opentimes': oprtimes,
'end_cash': endcash,
'SR': SR,
'Annual':Annual,
'Sharpe':Sharpe,
'DrawBack':DrawBack,
'max_single_loss_rate': max_single_loss_rate
}
print results
filename = ("%s%d %d %s result.csv" % (symbolInfo.symbol, K_MIN_SAR, K_MIN_MACD,setname))
result.to_csv(filename)
del rawdata_sar
del rawdata_macd
return results
