def dual_thrust_sim( mdf, config):
ddf = config['ddf']
close_daily = config['close_daily']
marginrate = config['marginrate']
offset = config['offset']
k = config['param'][0]
win = config['param'][1]
multiplier = config['param'][2]
f = config['param'][3]
ep_enabled = config['EP']
start_equity = config['capital']
chan = config['chan']
chan_func = config['chan_func']
tcost = config['trans_cost']
unit = config['unit']
SL = config['stoploss']
min_rng = config['min_range']
no_trade_set = config['no_trade_set']
if win == -1:
tr= pd.concat([ddf.high - ddf.low, ddf.close - ddf.close.shift(1)],
join='outer', axis=1).max(axis=1).shift(1)
elif win == 0:
tr = pd.concat([(pd.rolling_max(ddf.high, 2) - pd.rolling_min(ddf.close, 2))*multiplier,
(pd.rolling_max(ddf.close, 2) - pd.rolling_min(ddf.low, 2))*multiplier,
ddf.high - ddf.close,
ddf.close - ddf.low],
join='outer', axis=1).max(axis=1).shift(1)
else:
tr= pd.concat([pd.rolling_max(ddf.high, win) - pd.rolling_min(ddf.close, win),
pd.rolling_max(ddf.close, win) - pd.rolling_min(ddf.low, win)],
join='outer', axis=1).max(axis=1).shift(1)
ddf['TR'] = tr
ddf['H1'] = eval(chan_func['high']['func'])(ddf, chan, **chan_func['high']['args']).shift(1)
ddf['L1'] = eval(chan_func['low']['func'])(ddf, chan, **chan_func['low']['args']).shift(1)
ll = mdf.shape[0]
mdf['pos'] = pd.Series([0]*ll, index = mdf.index)
mdf['cost'] = pd.Series([0]*ll, index = mdf.index)
curr_pos = []
closed_trades = []
start_d = ddf.index[0]
end_d = mdf.index[-1].date()
prev_d = start_d - datetime.timedelta(days=1)
tradeid = 0
for dd in mdf.index:
mslice = mdf.ix[dd]
min_id = agent.get_min_id(dd)
d = dd.date()
dslice = ddf.ix[d]
if np.isnan(dslice.TR) or (mslice.close == 0):
continue
if (mslice.low == 0):
mslice.low = mslice.close
if mslice.high >= mslice.open * 1.2:
mslice.high = mslice.close
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, 'pos'] = pos
d_open = dslice.open
if (prev_d < d):
d_open = mslice.open
d_high = mslice.high
d_low = mslice.low
else:
d_open = dslice.open
d_high = max(d_high, mslice.high)
d_low = min(d_low, mslice.low)
if (d_open <= 0):
continue
prev_d = d
buytrig = d_open + max(min_rng * d_open, dslice.TR * k)
selltrig = d_open - max(min_rng * d_open, dslice.TR * k)
if ep_enabled:
buytrig = max(buytrig, d_high)
selltrig = min(selltrig, d_low)
if (min_id >= config['exit_min']) :
if (pos != 0) and (close_daily or (d == end_d)):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset , dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
elif min_id not in no_trade_set:
if (pos!=0) and (SL>0):
curr_pos[0].trail_update(mslice.close)
if curr_pos[0].check_exit(mslice.close, SL*mslice.close):
curr_pos[0].close(mslice.close-offset*misc.sign(pos), dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
if (mslice.high >= buytrig) and (pos <=0 ):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close+offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
if mslice.high >= dslice.H1:
new_pos = strat.TradePos([mslice.contract], [1], unit, mslice.close + offset, mslice.close + offset)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + offset, dd)
curr_pos.append(new_pos)
pos = unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
elif (mslice.low <= selltrig) and (pos >=0 ):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close-offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
if mslice.low <= dslice.L1:
new_pos = strat.TradePos([mslice.contract], [1], -unit, mslice.close - offset, mslice.close - offset)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close - offset, dd)
curr_pos.append(new_pos)
pos = -unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
mdf.ix[dd, 'pos'] = pos
(res_pnl, ts) = backtest.get_pnl_stats( mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats( closed_trades )
res = dict( res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def dual_thrust_sim( mdf, config):
close_daily = config['close_daily']
marginrate = config['marginrate']
offset = config['offset']
k = config['param'][0]
win = config['param'][1]
multiplier = config['param'][2]
f = config['param'][3]
pos_update = config['pos_update']
pos_class = config['pos_class']
pos_args = config['pos_args']
proc_func = config['proc_func']
proc_args = config['proc_args']
start_equity = config['capital']
chan_func = config['chan_func']
chan_high = eval(chan_func['high']['func'])
chan_low = eval(chan_func['low']['func'])
tcost = config['trans_cost']
unit = config['unit']
SL = config['stoploss']
min_rng = config['min_range']
chan = config['chan']
use_chan = config['use_chan']
no_trade_set = config['no_trade_set']
ll = mdf.shape[0]
xdf = proc_func(mdf, **proc_args)
if win == -1:
tr= pd.concat([xdf.high - xdf.low, abs(xdf.close - xdf.close.shift(1))],
join='outer', axis=1).max(axis=1)
elif win == 0:
tr = pd.concat([(pd.rolling_max(xdf.high, 2) - pd.rolling_min(xdf.close, 2))*multiplier,
(pd.rolling_max(xdf.close, 2) - pd.rolling_min(xdf.low, 2))*multiplier,
xdf.high - xdf.close,
xdf.close - xdf.low],
join='outer', axis=1).max(axis=1)
else:
tr= pd.concat([pd.rolling_max(xdf.high, win) - pd.rolling_min(xdf.close, win),
pd.rolling_max(xdf.close, win) - pd.rolling_min(xdf.low, win)],
join='outer', axis=1).max(axis=1)
xdf['TR'] = tr
xdf['chan_h'] = chan_high(xdf, chan, **chan_func['high']['args'])
xdf['chan_l'] = chan_low(xdf, chan, **chan_func['low']['args'])
xdf['MA'] = pd.rolling_mean(xdf.close, chan)
xdata = pd.concat([xdf['TR'].shift(1), xdf['MA'].shift(1),
xdf['chan_h'].shift(1), xdf['chan_l'].shift(1),
xdf['open']], axis=1, keys=['TR','MA', 'chanH', 'chanL', 'dopen']).fillna(0)
mdf = mdf.join(xdata, how = 'left').fillna(method='ffill')
mdf['pos'] = pd.Series([0]*ll, index = mdf.index)
mdf['cost'] = pd.Series([0]*ll, index = mdf.index)
curr_pos = []
closed_trades = []
end_d = mdf.index[-1].date
#prev_d = start_d - datetime.timedelta(days=1)
tradeid = 0
for dd in mdf.index:
mslice = mdf.ix[dd]
min_id = mslice.min_id
min_cnt = (min_id-300)/100 * 60 + min_id % 100 + 1
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, 'pos'] = pos
if (mslice.TR == 0) or (mslice.MA == 0):
continue
d_open = mslice.dopen
rng = max(min_rng * d_open, k * mslice.TR)
if (d_open <= 0):
continue
buytrig = d_open + rng
selltrig = d_open - rng
if 'reset_margin' in pos_args:
pos_args['reset_margin'] = mslice.TR * SL
if mslice.MA > mslice.close:
buytrig += f * rng
elif mslice.MA < mslice.close:
selltrig -= f * rng
if (min_id >= config['exit_min']) and (close_daily or (mslice.date == end_d)):
if (pos != 0):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset , dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
elif min_id not in no_trade_set:
if (pos!=0) and pos_update:
curr_pos[0].update_price(mslice.close)
if (curr_pos[0].check_exit( mslice.close, SL * mslice.close )):
curr_pos[0].close(mslice.close-offset*misc.sign(pos), dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
if (mslice.high >= buytrig) and (pos <=0 ):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close+offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
if (use_chan == False) or (mslice.high > mslice.chanH):
new_pos = pos_class([mslice.contract], [1], unit, mslice.close + offset, mslice.close + offset, **pos_args)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + offset, dd)
curr_pos.append(new_pos)
pos = unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
elif (mslice.low <= selltrig) and (pos >=0 ):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close-offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
if (use_chan == False) or (mslice.low < mslice.chanL):
new_pos = pos_class([mslice.contract], [1], -unit, mslice.close - offset, mslice.close - offset, **pos_args)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close - offset, dd)
curr_pos.append(new_pos)
pos = -unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
mdf.ix[dd, 'pos'] = pos
(res_pnl, ts) = backtest.get_pnl_stats( mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats( closed_trades )
res = dict( res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def r_breaker_sim( ddf, mdf, config):
marginrate = config['marginrate']
offset = config['offset']
k = config['k']
a = k[0]
b = k[1]
c = k[2]
start_equity = config['capital']
tcost = config['trans_cost']
unit = config['unit']
close_daily = config['close_daily']
ddf['range'] = (ddf.high - ddf.low).shift(1)
ddf['ssetup'] = (ddf.high+a*(ddf.close - ddf.low)).shift(1)
ddf['bsetup'] = (ddf.low-a*(ddf.high - ddf.close)).shift(1)
ddf['senter'] = ((1+b)*(ddf.high+ddf.close)/2.0 - b * ddf.low).shift(1)
ddf['benter'] = ((1+b)*(ddf.low+ddf.close)/2.0 - b * ddf.high).shift(1)
ddf['bbreak'] = ddf.ssetup + c * (ddf.ssetup - ddf.bsetup)
ddf['sbreak'] = ddf.bsetup - c * (ddf.ssetup - ddf.bsetup)
ll = mdf.shape[0]
mdf['pos'] = pd.Series([0]*ll, index = mdf.index)
mdf['cost'] = pd.Series([0]*ll, index = mdf.index)
curr_pos = []
closed_trades = []
start_d = ddf.index[0]
end_d = mdf.index[-1].date()
prev_d = start_d - datetime.timedelta(days=1)
tradeid = 0
cur_high = 0
cur_low = 0
for dd in mdf.index:
mslice = mdf.ix[dd]
min_id = agent.get_min_id(dd)
d = dd.date()
dslice = ddf.ix[d]
if np.isnan(dslice.bbreak):
continue
if (prev_d < d):
num_trades = 0
cur_high = mslice.high
cur_low = mslice.low
else:
cur_high = max([cur_high, mslice.high])
cur_low = min([cur_low, mslice.low])
prev_d = d
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, 'pos'] = pos
if (min_id >= config['exit_min']):
if (pos != 0) and (close_daily or (d == end_d)):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset , dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
elif (min_id <= config['start_min']):
continue
else:
if num_trades >=2:
continue
if ((cur_high < dslice.bbreak) and (cur_high >= dslice.ssetup) and (mslice.close < dslice.senter) and (pos >=0)) or \
((cur_low > dslice.sbreak) and (cur_low <= dslice.bsetup) and (mslice.close > dslice.benter) and (pos <=0)):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close-misc.sign(pos)*offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
new_pos = strat.TradePos([mslice.contract], [1], -unit*misc.sign(pos), mslice.close, 0)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + offset*misc.sign(pos), dd)
curr_pos.append(new_pos)
pos = -unit*misc.sign(pos)
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
num_trades += 1
elif ((mslice.close >= dslice.bbreak) or (mslice.close <= dslice.sbreak)) and (pos == 0):
if (mslice.close >= dslice.bbreak):
direction = 1
else:
direction = -1
new_pos = strat.TradePos([mslice.contract], [1], unit*direction, mslice.close, 0)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + offset*misc.sign(direction), dd)
curr_pos.append(new_pos)
pos = unit*direction
mdf.ix[dd, 'cost'] -= abs(direction) * (offset + mslice.close*tcost)
num_trades += 1
mdf.ix[dd, 'pos'] = pos
(res_pnl, ts) = backtest.get_pnl_stats( mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats( closed_trades )
res = dict( res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def turtle_sim( mdf, config ):
ddf = config['ddf']
marginrate = config['marginrate']
offset = config['offset']
start_equity = config['capital']
tcost = config['trans_cost']
chan = config['chan']
unit = config['unit']
param = config['param']
max_pos = param[1]
max_loss = param[0]
ma_ratio = config['ma_ratio']
use_ma = config['use_ma']
chan_func = config['chan_func']
pos_update = config['pos_update']
ddf['ATR'] =dh.ATR(ddf, n=chan[0]).shift(1)
ddf['OL_1'] = eval(chan_func['high']['func'])(ddf, chan[0]).shift(1)
ddf['OS_1'] = eval(chan_func['low']['func'])(ddf, chan[0]).shift(1)
ddf['CL_1'] = eval(chan_func['low']['func'])(ddf, chan[1]).shift(1)
ddf['CS_1'] = eval(chan_func['high']['func'])(ddf, chan[1]).shift(1)
ddf['MA1'] = dh.MA(ddf, ma_ratio*chan[0]).shift(1)
ddf['MA2'] = dh.MA(ddf, chan[1]).shift(1)
ll = mdf.shape[0]
mdf['pos'] = pd.Series([0]*ll, index = mdf.index)
mdf['cost'] = pd.Series([0]*ll, index = mdf.index)
curr_pos = []
tradeid = 0
closed_trades = []
end_d = mdf.index[-1].date()
curr_atr = 0
for idx, dd in enumerate(mdf.index):
mslice = mdf.ix[dd]
min_id = mslice.min_id
d = dd.date()
dslice = ddf.ix[d]
tot_pos = sum( [trade.pos for trade in curr_pos] )
mdf.ix[dd, 'pos'] = tot_pos
if np.isnan(dslice.ATR):
continue
if (min_id >= config['exit_min']) :
if (tot_pos != 0) and (d == end_d):
for trade_pos in curr_pos:
trade_pos.close(mslice.close - misc.sign(trade_pos.pos) * offset, dd)
tradeid += 1
trade_pos.exit_tradeid = tradeid
closed_trades.append(trade_pos)
mdf.ix[dd, 'cost'] -= abs(trade_pos.pos) * (offset + mslice.close*tcost)
curr_pos = []
tot_pos = 0
else:
if tot_pos == 0:
curr_atr = dslice.ATR
direction = 0
dol = dslice.OL_1
dos = dslice.OS_1
if (mslice.close >= dol) and ((use_ma == False) or (mslice.MA1 >= mslice.MA2)):
direction = 1
elif (mslice.close <= dos) and ((use_ma == False) or (mslice.MA1 <= mslice.MA2)):
direction = -1
pos = direction * unit
if direction != 0:
new_pos = strat.TradePos([mslice.contract], [1], pos, mslice.close, mslice.close)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + direction * offset, dd)
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
curr_pos.append(new_pos)
else:
direction = curr_pos[0].direction
#exit position out of channel
if (direction == 1 and mslice.close <= dslice.CL_1) or \
(direction == -1 and mslice.close >= dslice.CS_1):
for trade_pos in curr_pos:
trade_pos.close(mslice.close - misc.sign(trade_pos.pos) * offset, dd)
tradeid += 1
trade_pos.exit_tradeid = tradeid
closed_trades.append(trade_pos)
mdf.ix[dd, 'cost'] -= abs(trade_pos.pos) * (offset + mslice.close*tcost)
curr_pos = []
#stop loss position partially
elif curr_pos[-1].check_exit( mslice.close, curr_atr * max_loss ):
for trade_pos in curr_pos:
if trade_pos.check_exit( mslice.close, curr_atr * max_loss ):
trade_pos.close(mslice.close - misc.sign(trade_pos.pos) * offset, dd)
tradeid += 1
trade_pos.exit_tradeid = tradeid
closed_trades.append(trade_pos)
mdf.ix[dd, 'cost'] -= abs(trade_pos.pos) * (offset + mslice.close*tcost)
curr_pos = [trade for trade in curr_pos if not trade.is_closed]
#add positions
elif (len(curr_pos) < max_pos) and (mslice.close - curr_pos[-1].entry_price)*direction > curr_atr/max_pos*max_loss:
for trade_pos in curr_pos:
#trade.exit_target += curr_atr/max_pos*max_loss * direction
trade_pos.set_exit( mslice.close )
new_pos = strat.TradePos([mslice.contract], [1], direction*unit, mslice.close, mslice.close)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + direction * offset, dd)
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
curr_pos.append(new_pos)
if (len(curr_pos) > 0) and pos_update:
for trade_pos in curr_pos:
trade_pos.update_price(mslice.close)
mdf.ix[dd, 'pos'] = sum( [trade.pos for trade in curr_pos] )
(res_pnl, ts) = backtest.get_pnl_stats( mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats( closed_trades )
res = dict( res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def dual_thrust_sim( ddf, mdf, config):
close_daily = config['close_daily']
marginrate = config['marginrate']
offset = config['offset']
k = config['k']
start_equity = config['capital']
win = config['win']
multiplier = config['m']
tcost = config['trans_cost']
unit = config['unit']
SL = config['stoploss']
min_rng = config['min_range']
if win == -1:
tr = (ddf.high - ddf.low).shift(1)
elif win == 0:
tr = pd.concat([(pd.rolling_max(ddf.high, 2) - pd.rolling_min(ddf.close, 2))*multiplier,
(pd.rolling_max(ddf.close, 2) - pd.rolling_min(ddf.low, 2))*multiplier,
ddf.high - ddf.close,
ddf.close - ddf.low],
join='outer', axis=1).max(axis=1).shift(1)
else:
tr= pd.concat([pd.rolling_max(ddf.high, win) - pd.rolling_min(ddf.close, win),
pd.rolling_max(ddf.close, win) - pd.rolling_min(ddf.low, win)],
join='outer', axis=1).max(axis=1).shift(1)
ddf['TR'] = tr
ll = mdf.shape[0]
mdf['pos'] = pd.Series([0]*ll, index = mdf.index)
mdf['cost'] = pd.Series([0]*ll, index = mdf.index)
curr_pos = []
closed_trades = []
start_d = ddf.index[0]
end_d = mdf.index[-1].date()
#prev_d = start_d - datetime.timedelta(days=1)
tradeid = 0
for dd in mdf.index:
mslice = mdf.ix[dd]
min_id = agent.get_min_id(dd)
d = dd.date()
dslice = ddf.ix[d]
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, 'pos'] = pos
if np.isnan(dslice.TR):
continue
d_open = dslice.open
#if (prev_d < d):
# d_open = mslice.open
#else:
# d_open = dslice.open
if (d_open <= 0):
continue
#prev_d = d
buytrig = d_open + max(min_rng, dslice.TR * k)
selltrig = d_open - max(min_rng, dslice.TR * k)
if (min_id >= config['exit_min']):
if (pos != 0) and (close_daily or (d == end_d)):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset , dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
else:
if (pos!=0) and (SL>0) and (curr_pos[0].trail_loss(mslice.close, SL*mslice.close)):
curr_pos[0].close(mslice.close-offset*misc.sign(pos), dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
if (mslice.close >= buytrig) and (pos <=0 ):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close+offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
new_pos = strat.TradePos([mslice.contract], [1], unit, buytrig, 0)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + offset, dd)
curr_pos.append(new_pos)
pos = unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
elif (mslice.close <= selltrig) and (pos >=0 ):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close-offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
new_pos = strat.TradePos([mslice.contract], [1], -unit, selltrig, 0)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close - offset, dd)
curr_pos.append(new_pos)
pos = -unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
mdf.ix[dd, 'pos'] = pos
(res_pnl, ts) = backtest.get_pnl_stats( mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats( closed_trades )
res = dict( res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def chanbreak_sim( mdf, ddf, config):
freq = config['freq']
str_freq = str(freq) + 'Min'
xdf = dh.conv_ohlc_freq(mdf, str_freq)
start_equity = config['capital']
tcost = config['trans_cost']
unit = config['unit']
k = config['scaler']
marginrate = config['marginrate']
offset = config['offset']
win = config['win']
chan_func = config['channel_func']
upper_chan_func = chan_func[0]
lower_chan_func = chan_func[1]
entry_chan = win
exit_chan = int(entry_chan/k[1])
xdf['H1'] = upper_chan_func(xdf, entry_chan).shift(1)
xdf['L1'] = lower_chan_func(xdf, entry_chan).shift(1)
xdf['H2'] = upper_chan_func(xdf, exit_chan).shift(1)
xdf['L2'] = lower_chan_func(xdf, exit_chan).shift(1)
ddf['ATR'] = dh.ATR(ddf, entry_chan)
ll = mdf.shape[0]
mdf['pos'] = pd.Series([0]*ll, index = mdf.index)
mdf['cost'] = pd.Series([0]*ll, index = mdf.index)
curr_pos = []
closed_trades = []
end_d = mdf.index[-1].date()
tradeid = 0
x_idx = 0
max_idx = len(xdf.index)
for idx, dd in enumerate(mdf.index):
mslice = mdf.ix[dd]
min_id = agent.get_min_id(dd)
d = dd.date()
dslice = ddf.ix[d]
while (x_idx<max_idx-1) and (xdf.index[x_idx + 1] < dd):
x_idx += 1
xslice = xdf.iloc[x_idx]
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, 'pos'] = pos
if np.isnan(dslice.ATR):
continue
if (min_id >=config['exit_min']):
if (pos!=0) and (d == end_d):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset , dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
continue
else:
if (pos !=0):
curr_pos[0].trail_update(mslice.close)
if curr_pos[0].trail_check(mslice.close, dslice.ATR*k[0]):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
pos = 0
curr_pos = []
if ((mslice.close >= xslice.H2) and (pos<0)) or ((mslice.close <= xslice.L2) and (pos>0)):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
if ((mslice.close>=xslice.H1) and (pos<=0)) or ((mslice.close <= xslice.L1) and (pos>=0)):
if (pos ==0 ):
target_pos = (mslice.close>=xslice.H1) * unit -(mslice.close<=xslice.L1) * unit
new_pos = strat.TradePos([mslice.contract], [1], target_pos, mslice.close, mslice.close)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + misc.sign(target_pos)*offset, dd)
curr_pos.append(new_pos)
mdf.ix[dd, 'cost'] -= abs(target_pos) * (offset + mslice.close*tcost)
mdf.ix[dd, 'pos'] = pos
else:
print "something wrong with position=%s, close =%s, upBnd=%s, lowBnd=%s" % ( pos, mslice.close, xslice.H1, xslice.L1)
(res_pnl, ts) = backtest.get_pnl_stats( mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats( closed_trades )
res = dict( res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def psar_test_sim(mdf, config):
close_daily = config['close_daily']
marginrate = config['marginrate']
offset = config['offset']
pos_update = config['pos_update']
pos_class = config['pos_class']
pos_args = config['pos_args']
proc_func = config['proc_func']
proc_args = config['proc_args']
start_equity = config['capital']
tcost = config['trans_cost']
unit = config['unit']
SL = config['stoploss']
chan = config['chan']
no_trade_set = config['no_trade_set']
ll = mdf.shape[0]
xdf = proc_func(mdf, **proc_args)
xdf['chan_h'] = pd.rolling_max(xdf.high, chan)
xdf['chan_l'] = pd.rolling_min(xdf.low, chan)
xdf['MA'] = pd.rolling_mean(xdf.close, chan)
psar_data = dh.PSAR(xdf, **config['sar_params'])
xdata = pd.concat(
[
xdf['MA'], xdf['chan_h'], xdf['chan_l'], psar_data['PSAR_VAL'],
psar_data['PSAR_DIR'], xdf['date_idx']
],
axis=1,
keys=['MA', 'chanH', 'chanL', 'psar', 'psar_dir', 'date'])
xdata = xdata.shift(1).fillna(0)
mdf = mdf.join(xdata, how='left').fillna(method='ffill')
mdf['pos'] = pd.Series([0] * ll, index=mdf.index)
mdf['cost'] = pd.Series([0] * ll, index=mdf.index)
curr_pos = []
closed_trades = []
end_d = mdf.index[-1].date
#prev_d = start_d - datetime.timedelta(days=1)
tradeid = 0
for dd in mdf.index:
mslice = mdf.ix[dd]
min_id = mslice.min_id
min_cnt = (min_id - 300) / 100 * 60 + min_id % 100 + 1
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, 'pos'] = pos
if (mslice.MA == 0) or (mslice.chanH
== 0) or (mslice.chanL
== 0) or (mslice.psar_dir == 0):
continue
if (min_id >= config['exit_min']) and (close_daily or
(mslice.datetime.date
== end_d)):
if (pos != 0):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd,
'cost'] -= abs(pos) * (offset + mslice.close * tcost)
pos = 0
elif min_id not in no_trade_set:
if (pos != 0) and pos_update:
curr_pos[0].update_price(mslice.close)
if (curr_pos[0].check_exit(mslice.close, SL * mslice.close)):
curr_pos[0].close(mslice.close - offset * misc.sign(pos),
dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset +
mslice.close * tcost)
pos = 0
long_close = ((mslice.low <= mslice.chanL) or
(mslice.psar_dir < 0)) and (pos > 0)
short_close = ((mslice.high >= mslice.chanH) or
(mslice.psar_dir > 0)) and (pos < 0)
close_price = mslice.close
if (short_close or long_close):
if (mslice.psar_dir > 0):
close_price = max(mslice.psar, mslice.open)
elif (mslice.psar_dir < 0):
close_price = min(mslice.psar, mslice.open)
curr_pos[0].close(mslice.close + offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
pos = 0
mdf.ix[dd,
'cost'] -= abs(pos) * (offset + mslice.close * tcost)
buy_trig = (mslice.high >= mslice.chanH) and (mslice.psar_dir >
0) and (pos == 0)
sell_trig = (mslice.low <= mslice.chanL) and (mslice.psar_dir <
0) and (pos == 0)
if buy_trig:
new_pos = pos_class([mslice.contract], [1], unit,
mslice.close + offset,
mslice.close + offset, **pos_args)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + offset, dd)
curr_pos.append(new_pos)
pos = unit
mdf.ix[dd,
'cost'] -= abs(pos) * (offset + mslice.close * tcost)
elif sell_trig:
new_pos = pos_class([mslice.contract], [1], -unit,
mslice.close - offset,
mslice.close - offset, **pos_args)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close - offset, dd)
curr_pos.append(new_pos)
pos = -unit
mdf.ix[dd,
'cost'] -= abs(pos) * (offset + mslice.close * tcost)
mdf.ix[dd, 'pos'] = pos
(res_pnl, ts) = backtest.get_pnl_stats(mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats(closed_trades)
res = dict(res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def aberration_sim( df, config):
marginrate = config['marginrate']
offset = config['offset']
win = config['win']
start_equity = config['capital']
tcost = config['trans_cost']
unit = config['unit']
k = config['scaler']
df['ma'] = dh.MA(df, win).shift(1)
std = dh.STDDEV(df, win).shift(1)
df['upbnd'] = df['ma'] + std * k[0]
df['lowbnd'] = df['ma'] - std * k[0]
ll = df.shape[0]
df['pos'] = pd.Series([0]*ll, index = df.index)
df['cost'] = pd.Series([0]*ll, index = df.index)
curr_pos = []
closed_trades = []
start_d = df.index[0].date()
end_d = df.index[-1].date()
tradeid = 0
for idx, dd in enumerate(df.index):
mslice = df.ix[dd]
min_id = agent.get_min_id(dd)
d = dd.date()
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
df.ix[dd, 'pos'] = pos
if np.isnan(mslice.ma):
continue
if (min_id >=config['exit_min']):
if (pos!=0) and (d == end_d):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset , dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
df.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
continue
else:
if ((mslice.close >= mslice.ma) and (pos<0)) or (mslice.close <= mslice.ma) and (pos>0 ) :
curr_pos[0].close(mslice.close - misc.sign(pos) * offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
df.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
if (mslice.close>=mslice.upbnd) or (mslice.close <= mslice.lowbnd):
if (pos ==0 ):
target_pos = (mslice.close>=mslice.upbnd) * unit -(mslice.close<=mslice.lowbnd) * unit
target = (mslice.close>=mslice.upbnd) * mslice.upbnd +(mslice.close<=mslice.lowbnd) * mslice.lowbnd
new_pos = strat.TradePos([mslice.contract], [1], target_pos, target, mslice.upbnd+mslice.lowbnd-target)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + misc.sign(target_pos)*offset, dd)
curr_pos.append(new_pos)
df.ix[dd, 'cost'] -= abs(target_pos) * (offset + mslice.close*tcost)
df.ix[dd, 'pos'] = pos
else:
print "something wrong with position=%s, close =%s, MA=%s, upBnd=%s, lowBnd=%s" % ( pos, mslice.close, mslice.ma, mslice.upbnd, mslice.lowbnd)
(res_pnl, ts) = backtest.get_pnl_stats( df, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats( closed_trades )
res = dict( res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def turtle_sim(mdf, config):
ddf = config['ddf']
marginrate = config['marginrate']
offset = config['offset']
start_equity = config['capital']
tcost = config['trans_cost']
chan = config['chan']
unit = config['unit']
param = config['param']
max_pos = param[1]
max_loss = param[0]
ma_ratio = config['ma_ratio']
use_ma = config['use_ma']
chan_func = config['chan_func']
pos_update = config['pos_update']
ddf['ATR'] = dh.ATR(ddf, n=chan[0]).shift(1)
ddf['OL_1'] = eval(chan_func['high']['func'])(ddf, chan[0]).shift(1)
ddf['OS_1'] = eval(chan_func['low']['func'])(ddf, chan[0]).shift(1)
ddf['CL_1'] = eval(chan_func['low']['func'])(ddf, chan[1]).shift(1)
ddf['CS_1'] = eval(chan_func['high']['func'])(ddf, chan[1]).shift(1)
ddf['MA1'] = dh.MA(ddf, ma_ratio * chan[0]).shift(1)
ddf['MA2'] = dh.MA(ddf, chan[1]).shift(1)
ll = mdf.shape[0]
mdf['pos'] = pd.Series([0] * ll, index=mdf.index)
mdf['cost'] = pd.Series([0] * ll, index=mdf.index)
curr_pos = []
tradeid = 0
closed_trades = []
end_d = mdf.index[-1].date()
curr_atr = 0
for idx, dd in enumerate(mdf.index):
mslice = mdf.ix[dd]
min_id = mslice.min_id
d = dd.date()
dslice = ddf.ix[d]
tot_pos = sum([trade.pos for trade in curr_pos])
mdf.ix[dd, 'pos'] = tot_pos
if np.isnan(dslice.ATR):
continue
if (min_id >= config['exit_min']):
if (tot_pos != 0) and (d == end_d):
for trade_pos in curr_pos:
trade_pos.close(
mslice.close - misc.sign(trade_pos.pos) * offset, dd)
tradeid += 1
trade_pos.exit_tradeid = tradeid
closed_trades.append(trade_pos)
mdf.ix[dd, 'cost'] -= abs(
trade_pos.pos) * (offset + mslice.close * tcost)
curr_pos = []
tot_pos = 0
else:
if tot_pos == 0:
curr_atr = dslice.ATR
direction = 0
dol = dslice.OL_1
dos = dslice.OS_1
if (mslice.close >= dol) and ((use_ma == False) or
(mslice.MA1 >= mslice.MA2)):
direction = 1
elif (mslice.close <= dos) and ((use_ma == False) or
(mslice.MA1 <= mslice.MA2)):
direction = -1
pos = direction * unit
if direction != 0:
new_pos = strat.TradePos([mslice.contract], [1], pos,
mslice.close, mslice.close)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + direction * offset, dd)
mdf.ix[dd, 'cost'] -= abs(pos) * (offset +
mslice.close * tcost)
curr_pos.append(new_pos)
else:
direction = curr_pos[0].direction
#exit position out of channel
if (direction == 1 and mslice.close <= dslice.CL_1) or \
(direction == -1 and mslice.close >= dslice.CS_1):
for trade_pos in curr_pos:
trade_pos.close(
mslice.close - misc.sign(trade_pos.pos) * offset,
dd)
tradeid += 1
trade_pos.exit_tradeid = tradeid
closed_trades.append(trade_pos)
mdf.ix[dd, 'cost'] -= abs(
trade_pos.pos) * (offset + mslice.close * tcost)
curr_pos = []
#stop loss position partially
elif curr_pos[-1].check_exit(mslice.close,
curr_atr * max_loss):
for trade_pos in curr_pos:
if trade_pos.check_exit(mslice.close,
curr_atr * max_loss):
trade_pos.close(
mslice.close -
misc.sign(trade_pos.pos) * offset, dd)
tradeid += 1
trade_pos.exit_tradeid = tradeid
closed_trades.append(trade_pos)
mdf.ix[dd, 'cost'] -= abs(trade_pos.pos) * (
offset + mslice.close * tcost)
curr_pos = [
trade for trade in curr_pos if not trade.is_closed
]
#add positions
elif (len(curr_pos) < max_pos
) and (mslice.close - curr_pos[-1].entry_price
) * direction > curr_atr / max_pos * max_loss:
for trade_pos in curr_pos:
#trade.exit_target += curr_atr/max_pos*max_loss * direction
trade_pos.set_exit(mslice.close)
new_pos = strat.TradePos([mslice.contract], [1],
direction * unit, mslice.close,
mslice.close)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + direction * offset, dd)
mdf.ix[dd, 'cost'] -= abs(pos) * (offset +
mslice.close * tcost)
curr_pos.append(new_pos)
if (len(curr_pos) > 0) and pos_update:
for trade_pos in curr_pos:
trade_pos.update_price(mslice.close)
mdf.ix[dd, 'pos'] = sum([trade.pos for trade in curr_pos])
(res_pnl, ts) = backtest.get_pnl_stats(mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats(closed_trades)
res = dict(res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def aberration_sim(df, config):
marginrate = config['marginrate']
offset = config['offset']
win = config['win']
start_equity = config['capital']
tcost = config['trans_cost']
unit = config['unit']
k = config['scaler']
df['ma'] = dh.MA(df, win).shift(1)
std = dh.STDDEV(df, win).shift(1)
df['upbnd'] = df['ma'] + std * k[0]
df['lowbnd'] = df['ma'] - std * k[0]
ll = df.shape[0]
df['pos'] = pd.Series([0] * ll, index=df.index)
df['cost'] = pd.Series([0] * ll, index=df.index)
curr_pos = []
closed_trades = []
start_d = df.index[0].date()
end_d = df.index[-1].date()
tradeid = 0
for idx, dd in enumerate(df.index):
mslice = df.ix[dd]
min_id = agent.get_min_id(dd)
d = dd.date()
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
df.ix[dd, 'pos'] = pos
if np.isnan(mslice.ma):
continue
if (min_id >= config['exit_min']):
if (pos != 0) and (d == end_d):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
df.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close * tcost)
continue
else:
if ((mslice.close >= mslice.ma) and
(pos < 0)) or (mslice.close <= mslice.ma) and (pos > 0):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
df.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close * tcost)
pos = 0
if (mslice.close >= mslice.upbnd) or (mslice.close <=
mslice.lowbnd):
if (pos == 0):
target_pos = (mslice.close >= mslice.upbnd) * unit - (
mslice.close <= mslice.lowbnd) * unit
target = (mslice.close >= mslice.upbnd) * mslice.upbnd + (
mslice.close <= mslice.lowbnd) * mslice.lowbnd
new_pos = strat.TradePos([mslice.contract], [1],
target_pos, target, mslice.upbnd +
mslice.lowbnd - target)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + misc.sign(target_pos) * offset,
dd)
curr_pos.append(new_pos)
df.ix[dd,
'cost'] -= abs(target_pos) * (offset +
mslice.close * tcost)
df.ix[dd, 'pos'] = pos
else:
print "something wrong with position=%s, close =%s, MA=%s, upBnd=%s, lowBnd=%s" % (
pos, mslice.close, mslice.ma, mslice.upbnd,
mslice.lowbnd)
(res_pnl, ts) = backtest.get_pnl_stats(df, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats(closed_trades)
res = dict(res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def dual_thrust_sim(mdf, config):
ddf = config['ddf']
close_daily = config['close_daily']
marginrate = config['marginrate']
offset = config['offset']
k = config['param'][0]
win = config['param'][1]
multiplier = config['param'][2]
f = config['param'][3]
ep_enabled = config['EP']
start_equity = config['capital']
chan = config['chan']
chan_func = config['chan_func']
tcost = config['trans_cost']
unit = config['unit']
SL = config['stoploss']
min_rng = config['min_range']
no_trade_set = config['no_trade_set']
if win == -1:
tr = pd.concat([ddf.high - ddf.low, ddf.close - ddf.close.shift(1)],
join='outer',
axis=1).max(axis=1).shift(1)
elif win == 0:
tr = pd.concat(
[(pd.rolling_max(ddf.high, 2) - pd.rolling_min(ddf.close, 2)) *
multiplier,
(pd.rolling_max(ddf.close, 2) - pd.rolling_min(ddf.low, 2)) *
multiplier, ddf.high - ddf.close, ddf.close - ddf.low],
join='outer',
axis=1).max(axis=1).shift(1)
else:
tr = pd.concat([
pd.rolling_max(ddf.high, win) - pd.rolling_min(ddf.close, win),
pd.rolling_max(ddf.close, win) - pd.rolling_min(ddf.low, win)
],
join='outer',
axis=1).max(axis=1).shift(1)
ddf['TR'] = tr
ddf['MA'] = pd.rolling_mean(ddf.close, chan).shift(1)
ddf['H1'] = eval(chan_func['high']['func'])(
ddf, chan, **chan_func['high']['args']).shift(1)
ddf['L1'] = eval(chan_func['low']['func'])(
ddf, chan, **chan_func['low']['args']).shift(1)
ll = mdf.shape[0]
mdf['pos'] = pd.Series([0] * ll, index=mdf.index)
mdf['cost'] = pd.Series([0] * ll, index=mdf.index)
curr_pos = []
closed_trades = []
start_d = ddf.index[0]
end_d = mdf.index[-1].date()
prev_d = start_d - datetime.timedelta(days=1)
tradeid = 0
for dd in mdf.index:
mslice = mdf.ix[dd]
min_id = mslice.min_id
d = mslice.date
dslice = ddf.ix[d]
if np.isnan(dslice.TR) or (mslice.close == 0):
continue
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, 'pos'] = pos
d_open = dslice.open
if (d_open <= 0):
continue
rng = max(min_rng * d_open, k * dslice.TR)
if (prev_d < d):
d_open = mslice.open
d_high = mslice.high
d_low = mslice.low
else:
d_open = dslice.open
d_high = max(d_high, mslice.high)
d_low = min(d_low, mslice.low)
prev_d = d
buytrig = d_open + rng
selltrig = d_open - rng
if dslice.MA > mslice.close:
buytrig += f * rng
elif dslice.MA < mslice.close:
selltrig -= f * rng
if ep_enabled:
buytrig = max(buytrig, d_high)
selltrig = min(selltrig, d_low)
if (min_id >= config['exit_min']):
if (pos != 0) and (close_daily or (d == end_d)):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd,
'cost'] -= abs(pos) * (offset + mslice.close * tcost)
pos = 0
elif min_id not in no_trade_set:
if (pos != 0) and (SL > 0):
curr_pos[0].trail_update(mslice.close)
if curr_pos[0].check_exit(mslice.close, SL * mslice.close):
curr_pos[0].close(mslice.close - offset * misc.sign(pos),
dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset +
mslice.close * tcost)
pos = 0
if (mslice.high >= buytrig) and (pos <= 0):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close + offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset +
mslice.close * tcost)
if mslice.high >= dslice.H1:
new_pos = strat.TradePos([mslice.contract], [1], unit,
mslice.close + offset,
mslice.close + offset)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + offset, dd)
curr_pos.append(new_pos)
pos = unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset +
mslice.close * tcost)
elif (mslice.low <= selltrig) and (pos >= 0):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close - offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset +
mslice.close * tcost)
if mslice.low <= dslice.L1:
new_pos = strat.TradePos([mslice.contract], [1], -unit,
mslice.close - offset,
mslice.close - offset)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close - offset, dd)
curr_pos.append(new_pos)
pos = -unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset +
mslice.close * tcost)
mdf.ix[dd, 'pos'] = pos
(res_pnl, ts) = backtest.get_pnl_stats(mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats(closed_trades)
res = dict(res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def dual_thrust_sim(ddf, mdf, config):
close_daily = config["close_daily"]
marginrate = config["marginrate"]
offset = config["offset"]
k = config["k"]
start_equity = config["capital"]
win = config["win"]
multiplier = config["m"]
tcost = config["trans_cost"]
unit = config["unit"]
SL = config["stoploss"]
min_rng = config["min_range"]
no_trade_set = config["no_trade_set"]
if win == -1:
tr = pd.concat([ddf.high - ddf.low, ddf.close - ddf.close.shift(1)], join="outer", axis=1).max(axis=1).shift(1)
elif win == 0:
tr = (
pd.concat(
[
(pd.rolling_max(ddf.high, 2) - pd.rolling_min(ddf.close, 2)) * multiplier,
(pd.rolling_max(ddf.close, 2) - pd.rolling_min(ddf.low, 2)) * multiplier,
ddf.high - ddf.close,
ddf.close - ddf.low,
],
join="outer",
axis=1,
)
.max(axis=1)
.shift(1)
)
else:
tr = (
pd.concat(
[
pd.rolling_max(ddf.high, win) - pd.rolling_min(ddf.close, win),
pd.rolling_max(ddf.close, win) - pd.rolling_min(ddf.low, win),
],
join="outer",
axis=1,
)
.max(axis=1)
.shift(1)
)
ddf["TR"] = tr
# ddf['prev_high'] = ddf.high.shift(1)
# ddf['prev_low'] = ddf.low.shift(1)
ll = mdf.shape[0]
mdf["pos"] = pd.Series([0] * ll, index=mdf.index)
mdf["cost"] = pd.Series([0] * ll, index=mdf.index)
curr_pos = []
closed_trades = []
start_d = ddf.index[0]
end_d = mdf.index[-1].date()
prev_d = start_d - datetime.timedelta(days=1)
tradeid = 0
for dd in mdf.index:
mslice = mdf.ix[dd]
min_id = agent.get_min_id(dd)
d = dd.date()
dslice = ddf.ix[d]
if min_id in no_trade_set or np.isnan(dslice.TR):
continue
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, "pos"] = pos
d_open = dslice.open
if prev_d < d:
d_open = mslice.open
# d_high = mslice.high
# d_low = mslice.low
else:
d_open = dslice.open
# d_high = max(d_high, mslice.high)
# d_low = min(d_low, mslice.low)
if d_open <= 0:
continue
prev_d = d
buytrig = d_open + max(min_rng * d_open, dslice.TR * k)
selltrig = d_open - max(min_rng * d_open, dslice.TR * k)
# d_high = max(d_high, dslice.prev_high)
# d_low = min(d_low, dslice.prev_low)
if min_id >= config["exit_min"]:
if (pos != 0) and (close_daily or (d == end_d)):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
pos = 0
else:
if (pos != 0) and (SL > 0):
curr_pos[0].trail_update(mslice.close)
if curr_pos[0].trail_check(mslice.close, SL * mslice.close):
curr_pos[0].close(mslice.close - offset * misc.sign(pos), dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
pos = 0
if (mslice.high >= buytrig) and (pos <= 0):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close + offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
new_pos = strat.TradePos([mslice.contract], [1], unit, mslice.close + offset, mslice.close + offset)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + offset, dd)
curr_pos.append(new_pos)
pos = unit
mdf.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
elif (mslice.low <= selltrig) and (pos >= 0):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close - offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
new_pos = strat.TradePos([mslice.contract], [1], -unit, mslice.close - offset, mslice.close - offset)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close - offset, dd)
curr_pos.append(new_pos)
pos = -unit
mdf.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
mdf.ix[dd, "pos"] = pos
(res_pnl, ts) = backtest.get_pnl_stats(mdf, start_equity, marginrate, "m")
res_trade = backtest.get_trade_stats(closed_trades)
res = dict(res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def ttl_soup_sim(mdf, config):
close_daily = config['close_daily']
marginrate = config['marginrate']
offset = config['offset']
pos_update = config['pos_update']
pos_class = config['pos_class']
pos_args = config['pos_args']
proc_func = config['proc_func']
proc_args = config['proc_args']
start_equity = config['capital']
tcost = config['trans_cost']
unit = config['unit']
SL = config['stoploss']
chan = config['chan']
exit_ratio = config['exit_ratio']
exit_chan = int(chan * exit_ratio)
gap_win = config['gap_win']
no_trade_set = config['no_trade_set']
ll = mdf.shape[0]
xdf = proc_func(mdf, **proc_args)
donch_data = dh.DONCH_IDX(xdf, chan)
hh_str = 'DONCH_H%s' % str(chan)
hidx_str = 'DONIDX_H%s' % str(chan)
ll_str = 'DONCH_L%s' % str(chan)
lidx_str = 'DONIDX_L%s' % str(chan)
xdf['exit_hh'] = pd.rolling_max(xdf.high, exit_chan)
xdf['exit_ll'] = pd.rolling_min(xdf.low, exit_chan)
xdf['ssetup'] = (xdf['close'] >= donch_data[hh_str].shift(1)) & (
donch_data[hidx_str] >= gap_win)
xdf['bsetup'] = (xdf['close'] <= donch_data[ll_str].shift(1)) & (
donch_data[lidx_str] >= gap_win)
atr = dh.ATR(xdf, chan)
donch_data['prevhh'] = donch_data[hh_str].shift(1)
donch_data['prevll'] = donch_data[ll_str].shift(1)
xdata = pd.concat([
donch_data[hidx_str], donch_data[hh_str], donch_data[lidx_str],
donch_data[ll_str], xdf['ssetup'], xdf['bsetup'], atr,
donch_data[hh_str].shift(1), donch_data[ll_str].shift(1)
],
axis=1,
keys=[
'hh_idx', 'hh', 'll_idx', 'll', 'ssetup', 'bsetup',
'ATR', 'prev_hh', 'prev_ll'
]).fillna(0)
xdata = xdata.shift(1)
mdf = mdf.join(xdata, how='left').fillna(method='ffill')
mdf['pos'] = pd.Series([0] * ll, index=mdf.index)
mdf['cost'] = pd.Series([0] * ll, index=mdf.index)
curr_pos = []
closed_trades = []
end_d = mdf.index[-1].date
#prev_d = start_d - datetime.timedelta(days=1)
tradeid = 0
for idx, dd in enumerate(mdf.index):
mslice = mdf.ix[dd]
min_id = mslice.min_id
min_cnt = (min_id - 300) / 100 * 60 + min_id % 100 + 1
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, 'pos'] = pos
if (mslice.prev_hh == 0):
continue
if (min_id >= config['exit_min']) and (close_daily or
(mslice.datetime.date
== end_d)):
if (pos != 0):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd,
'cost'] -= abs(pos) * (offset + mslice.close * tcost)
pos = 0
elif min_id not in no_trade_set:
if (pos != 0):
exit_flag = False
if ((pos > 0) and (mslice.close <= mslice.exit_ll)) or (
(pos < 0) and (mslice.close >= mslice.exit_hh)):
exit_flag = True
if exit_flag or curr_pos[0].check_exit(mslice.close, 0):
curr_pos[0].close(mslice.close - offset * misc.sign(pos),
dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset +
mslice.close * tcost)
pos = 0
elif pos_update and (min_cnt % config['pos_freq'] == 0):
curr_pos[0].update_price(mslice.close)
if mslice.bsetup and (pos
== 0) and (mslice.close >= mslice.prev_ll):
new_pos = pos_class([mslice.contract], [1], unit,
mslice.close + offset, mslice.low,
**pos_args)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + offset, dd)
curr_pos.append(new_pos)
pos = unit
mdf.ix[dd,
'cost'] -= abs(pos) * (offset + mslice.close * tcost)
elif mslice.ssetup and (pos
== 0) and mslice.close <= mslice.prev_hh:
new_pos = pos_class([mslice.contract], [1], -unit,
mslice.close - offset, mslice.high,
**pos_args)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close - offset, dd)
curr_pos.append(new_pos)
pos = -unit
mdf.ix[dd,
'cost'] -= abs(pos) * (offset + mslice.close * tcost)
mdf.ix[dd, 'pos'] = pos
(res_pnl, ts) = backtest.get_pnl_stats(mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats(closed_trades)
res = dict(res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def dual_thrust_sim( mdf, config):
close_daily = config['close_daily']
marginrate = config['marginrate']
offset = config['offset']
k = config['k']
f = config['f']
start_equity = config['capital']
win = config['win']
multiplier = config['m']
tcost = config['trans_cost']
unit = config['unit']
SL = config['stoploss']
min_rng = config['min_range']
ma_fast = config['MA_fast']
ll = mdf.shape[0]
mdf['min_idx'] = pd.Series(1, index = mdf.index)
mdf.loc[mdf['min_id']<1500, 'min_idx'] = 0
mdf['date_idx'] = mdf.index.date
xdf = mdf.groupby([mdf['date_idx'], mdf['min_idx']]).apply(dh.ohlcsum).reset_index().set_index('datetime')
if win == -1:
tr= pd.concat([xdf.high - xdf.low, abs(xdf.close - xdf.close.shift(1))],
join='outer', axis=1).max(axis=1).shift(1)
elif win == -2:
tr= pd.rolling_max(xdf.high, 2) - pd.rolling_min(xdf.low, 2)
elif win == 0:
tr = pd.concat([(pd.rolling_max(xdf.high, 2) - pd.rolling_min(xdf.close, 2))*multiplier,
(pd.rolling_max(xdf.close, 2) - pd.rolling_min(xdf.low, 2))*multiplier,
xdf.high - xdf.close,
xdf.close - xdf.low],
join='outer', axis=1).max(axis=1).shift(1)
else:
tr= pd.concat([pd.rolling_max(xdf.high, win) - pd.rolling_min(xdf.close, win),
pd.rolling_max(xdf.close, win) - pd.rolling_min(xdf.low, win)],
join='outer', axis=1).max(axis=1).shift(1)
xdf['TR'] = tr
xdf['MA'] = pd.rolling_mean(xdf.close, ma_fast).shift(1)
ddf = pd.concat([xdf['TR'], xdf['MA'], xdf['open'], xdf['date_idx']], axis=1, keys=['TR','MA','dopen', 'date']).fillna(0)
mdf = mdf.join(ddf, how = 'left').fillna(method='ffill')
mdf['pos'] = pd.Series([0]*ll, index = mdf.index)
mdf['cost'] = pd.Series([0]*ll, index = mdf.index)
curr_pos = []
closed_trades = []
start_d = ddf.index[0]
end_d = mdf.index[-1].date()
#prev_d = start_d - datetime.timedelta(days=1)
tradeid = 0
for dd in mdf.index:
mslice = mdf.ix[dd]
min_id = agent.get_min_id(dd)
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, 'pos'] = pos
if mslice.TR == 0 or mslice.MA == 0:
continue
d_open = mslice.dopen
#if (prev_d < d):
# d_open = mslice.open
#else:
# d_open = dslice.open
rng = max(min_rng * d_open, k * mslice.TR)
if (d_open <= 0):
continue
buytrig = d_open + rng
selltrig = d_open - rng
if mslice.MA > mslice.close:
buytrig += f * rng
elif mslice.MA < mslice.close:
selltrig -= f * rng
if (min_id >= config['exit_min']) and (close_daily or (mslice.date == end_d)):
if (pos != 0):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset , dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
else:
if (pos!=0) and (SL>0):
curr_pos[0].trail_update(mslice.close)
if (curr_pos[0].trail_check(mslice.close, SL*mslice.close)):
curr_pos[0].close(mslice.close-offset*misc.sign(pos), dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
if (mslice.high >= buytrig) and (pos <=0 ):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close+offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
new_pos = strat.TradePos([mslice.contract], [1], unit, mslice.close + offset, mslice.close + offset)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + offset, dd)
curr_pos.append(new_pos)
pos = unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
elif (mslice.low <= selltrig) and (pos >=0 ):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close-offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
new_pos = strat.TradePos([mslice.contract], [1], -unit, mslice.close - offset, mslice.close - offset)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close - offset, dd)
curr_pos.append(new_pos)
pos = -unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
mdf.ix[dd, 'pos'] = pos
(res_pnl, ts) = backtest.get_pnl_stats( mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats( closed_trades )
res = dict( res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def chanbreak_sim( mdf, config):
freq = config['freq']
str_freq = str(freq) + 'Min'
xdf = dh.conv_ohlc_freq(mdf, str_freq)
start_equity = config['capital']
tcost = config['trans_cost']
unit = config['unit']
#k = config['scaler']
marginrate = config['marginrate']
offset = config['offset']
win = config['win']
pos_class = config['pos_class']
pos_args = config['pos_args']
chan_func = config['channel_func']
upper_chan_func = chan_func[0]
lower_chan_func = chan_func[1]
entry_chan = win[0]
exit_chan = win[1]
xdf['H1'] = upper_chan_func(xdf, entry_chan)
xdf['L1'] = lower_chan_func(xdf, entry_chan)
xdf['H2'] = upper_chan_func(xdf, exit_chan)
xdf['L2'] = lower_chan_func(xdf, exit_chan)
xdf['ATR'] = dh.ATR(xdf, entry_chan)
xdata = pd.concat([xdf['H1'], xdf['L1'], xdf['H2'], xdf['L2'], xdf['ATR'], xdf['high'], xdf['low']], \
axis=1, keys=['H1', 'L1', 'H2', 'L2', 'ATR', 'xhigh', 'xlow']).shift(1)
ll = mdf.shape[0]
mdf = mdf.join(xdata, how = 'left').fillna(method='ffill')
mdf['pos'] = pd.Series([0]*ll, index = mdf.index)
mdf['cost'] = pd.Series([0]*ll, index = mdf.index)
curr_pos = []
closed_trades = []
end_d = mdf.index[-1].date()
tradeid = 0
x_idx = 0
max_idx = len(xdf.index)
for idx, dd in enumerate(mdf.index):
mslice = mdf.ix[dd]
min_id = mslice.min_id
cnt_id = count_min_id(dd)
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, 'pos'] = pos
#if np.isnan(mslice.ATR):
# continue
if (min_id >=config['exit_min']):
if (pos!=0) and (dd.date() == end_d):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset , dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
pos = 0
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
continue
else:
if (pos !=0):
if (cnt_id % freq) == 0:
curr_pos[0].update_bar(mslice)
check_price = (pos>0) * mslice.low + (pos<0) * mslice.high
if curr_pos[0].check_exit(check_price, 0):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
pos = 0
curr_pos = []
if ((mslice.high >= mslice.H2) and (pos<0)) or ((mslice.low <= mslice.L2) and (pos>0)):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
if ((mslice.high >= mslice.H1) and (pos<=0)) or ((mslice.low <= mslice.L1) and (pos>=0)):
if (pos ==0 ):
pos = (mslice.high >= mslice.H1) * unit -(mslice.low <= mslice.L1) * unit
exit_target = (mslice.high >= mslice.H1) * mslice.L2 + (mslice.low <= mslice.L1) * mslice.H2
new_pos = pos_class([mslice.contract], [1], pos, mslice.close, exit_target, 1, **pos_args)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + misc.sign(pos)*offset, dd)
curr_pos.append(new_pos)
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
mdf.ix[dd, 'pos'] = pos
(res_pnl, ts) = backtest.get_pnl_stats( mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats( closed_trades )
res = dict( res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def ttl_soup_sim( mdf, config):
close_daily = config['close_daily']
marginrate = config['marginrate']
offset = config['offset']
pos_update = config['pos_update']
pos_class = config['pos_class']
pos_args = config['pos_args']
proc_func = config['proc_func']
proc_args = config['proc_args']
start_equity = config['capital']
tcost = config['trans_cost']
unit = config['unit']
SL = config['stoploss']
chan = config['chan']
exit_ratio = config['exit_ratio']
exit_chan = int(chan * exit_ratio)
gap_win = config['gap_win']
no_trade_set = config['no_trade_set']
ll = mdf.shape[0]
xdf = proc_func(mdf, **proc_args)
donch_data = dh.DONCH_IDX(xdf, chan)
hh_str = 'DONCH_H%s' % str(chan)
hidx_str = 'DONIDX_H%s' % str(chan)
ll_str = 'DONCH_L%s' % str(chan)
lidx_str = 'DONIDX_L%s' % str(chan)
xdf['exit_hh'] = pd.rolling_max(xdf.high, exit_chan)
xdf['exit_ll'] = pd.rolling_min(xdf.low, exit_chan)
xdf['ssetup'] = (xdf['close'] >= donch_data[hh_str].shift(1)) & (donch_data[hidx_str]>=gap_win)
xdf['bsetup'] = (xdf['close'] <= donch_data[ll_str].shift(1)) & (donch_data[lidx_str]>=gap_win)
atr = dh.ATR(xdf, chan)
donch_data['prevhh'] = donch_data[hh_str].shift(1)
donch_data['prevll'] = donch_data[ll_str].shift(1)
xdata = pd.concat([donch_data[hidx_str], donch_data[hh_str],
donch_data[lidx_str], donch_data[ll_str],
xdf['ssetup'], xdf['bsetup'],atr,
donch_data[hh_str].shift(1), donch_data[ll_str].shift(1)],
axis=1, keys=['hh_idx', 'hh', 'll_idx', 'll', 'ssetup', 'bsetup', 'ATR', 'prev_hh', 'prev_ll']).fillna(0)
xdata = xdata.shift(1)
mdf = mdf.join(xdata, how = 'left').fillna(method='ffill')
mdf['pos'] = pd.Series([0]*ll, index = mdf.index)
mdf['cost'] = pd.Series([0]*ll, index = mdf.index)
curr_pos = []
closed_trades = []
end_d = mdf.index[-1].date
#prev_d = start_d - datetime.timedelta(days=1)
tradeid = 0
for idx, dd in enumerate(mdf.index):
mslice = mdf.ix[dd]
min_id = mslice.min_id
min_cnt = (min_id-300)/100 * 60 + min_id % 100 + 1
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, 'pos'] = pos
if (mslice.prev_hh == 0):
continue
if (min_id >= config['exit_min']) and (close_daily or (mslice.datetime.date == end_d)):
if (pos != 0):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset , dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
elif min_id not in no_trade_set:
if (pos!=0):
exit_flag = False
if ((pos > 0) and (mslice.close <= mslice.exit_ll)) or ((pos < 0) and (mslice.close >= mslice.exit_hh)):
exit_flag = True
if exit_flag or curr_pos[0].check_exit( mslice.close, 0):
curr_pos[0].close(mslice.close-offset*misc.sign(pos), dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
elif pos_update and (min_cnt % config['pos_freq'] == 0):
curr_pos[0].update_price(mslice.close)
if mslice.bsetup and (pos == 0) and (mslice.close>=mslice.prev_ll):
new_pos = pos_class([mslice.contract], [1], unit, mslice.close + offset, mslice.low, **pos_args)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + offset, dd)
curr_pos.append(new_pos)
pos = unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
elif mslice.ssetup and (pos == 0) and mslice.close<=mslice.prev_hh:
new_pos = pos_class([mslice.contract], [1], -unit, mslice.close - offset, mslice.high, **pos_args)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close - offset, dd)
curr_pos.append(new_pos)
pos = -unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
mdf.ix[dd, 'pos'] = pos
(res_pnl, ts) = backtest.get_pnl_stats( mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats( closed_trades )
res = dict( res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def turtle_sim( ddf, mdf, config ):
marginrate = config['marginrate']
offset = config['offset']
start_equity = config['capital']
tcost = config['trans_cost']
signals = config['signals']
unit = config['unit']
NN = config['max_loss']
max_pos = config['max_pos']
use_MA = False
if signals[2] > 1:
use_MA = True
start_idx = 0
trail_loss = config['trail_loss']
ddf['ATR'] = pd.Series(dh.ATR(ddf, n=signals[0]).shift(1))
ddf['OL_1'] = pd.Series(dh.DONCH_H(ddf, signals[0]).shift(1))
ddf['OS_1'] = pd.Series(dh.DONCH_L(ddf, signals[0]).shift(1))
ddf['CL_1'] = pd.Series(dh.DONCH_L(ddf, signals[1]).shift(1))
ddf['CS_1'] = pd.Series(dh.DONCH_H(ddf, signals[1]).shift(1))
if use_MA:
ddf['MA'] = pd.Series(dh.MA(ddf, signals[2]*signals[0]).shift(1))
else:
ddf['MA'] = pd.Series(0, index=ddf.index)
ll = mdf.shape[0]
mdf['pos'] = pd.Series([0]*ll, index = mdf.index)
mdf['cost'] = pd.Series([0]*ll, index = mdf.index)
curr_pos = []
tradeid = 0
closed_trades = []
curr_atr = 0
for idx, dd in enumerate(mdf.index):
mslice = mdf.ix[dd]
d = dd.date()
dslice = ddf.ix[d]
tot_pos = sum( [trade.pos for trade in curr_pos] )
mdf.ix[dd, 'pos'] = tot_pos
if (idx < start_idx) or np.isnan(dslice.ATR):
continue
if len(curr_pos) == 0 and idx < len(mdf.index)-NO_OPEN_POS_PROTECT:
curr_atr = dslice.ATR
direction = 0
dol = dslice.OL_1
dos = dslice.OS_1
if use_MA:
dol = max(dol, dslice.MA)
dos = min(dos, dslice.MA)
if mslice.close >= dol:
direction = 1
elif mslice.close <= dos:
direction = -1
pos = direction * unit
if direction != 0:
new_pos = strat.TradePos([mslice.contract], [1], pos, mslice.close, mslice.close)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + direction * offset, dd)
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
curr_pos.append(new_pos)
curr_atr = dslice.ATR
elif (idx >= len(mdf.index)-NO_OPEN_POS_PROTECT):
if len(curr_pos)>0:
for trade_pos in curr_pos:
trade_pos.close(mslice.close - misc.sign(trade_pos.pos) * offset, dd)
tradeid += 1
trade_pos.exit_tradeid = tradeid
closed_trades.append(trade_pos)
mdf.ix[dd, 'cost'] -= abs(trade_pos.pos) * (offset + mslice.close*tcost)
curr_pos = []
else:
direction = curr_pos[0].direction
if trail_loss:
for trade_pos in curr_pos:
trade_pos.trail_update(mslice.close)
#exit position out of channel
if (direction == 1 and mslice.close <= dslice.CL_1) or \
(direction == -1 and mslice.close >= dslice.CS_1):
for trade_pos in curr_pos:
trade_pos.close(mslice.close - misc.sign(trade_pos.pos) * offset, dd)
tradeid += 1
trade_pos.exit_tradeid = tradeid
closed_trades.append(trade_pos)
mdf.ix[dd, 'cost'] -= abs(trade_pos.pos) * (offset + mslice.close*tcost)
curr_pos = []
#stop loss position partially
elif curr_pos[-1].trail_check( mslice.close, curr_atr * NN ):
for trade_pos in curr_pos:
if trade_pos.trail_check( mslice.close, curr_atr * NN )>0:
trade_pos.close(mslice.close - misc.sign(trade_pos.pos) * offset, dd)
tradeid += 1
trade_pos.exit_tradeid = tradeid
closed_trades.append(trade_pos)
mdf.ix[dd, 'cost'] -= abs(trade_pos.pos) * (offset + mslice.close*tcost)
curr_pos = [trade for trade in curr_pos if not trade.is_closed]
#add positions
elif (len(curr_pos) < max_pos) and (mslice.close - curr_pos[-1].entry_price)*direction > curr_atr/max_pos*NN:
for trade_pos in curr_pos:
#trade.exit_target += curr_atr/max_pos*NN * direction
trade_pos.exit_target = mslice.close
new_pos = strat.TradePos([mslice.contract], [1], direction*unit, mslice.close, mslice.close)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + direction * offset, dd)
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
curr_pos.append(new_pos)
mdf.ix[dd, 'pos'] = sum( [trade.pos for trade in curr_pos] )
(res_pnl, ts) = backtest.get_pnl_stats( mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats( closed_trades )
res = dict( res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def fisher_swing_sim(df, xdf, config):
marginrate = config["marginrate"]
offset = config["offset"]
win = config["win"]
start_equity = config["capital"]
tcost = config["trans_cost"]
unit = config["unit"]
fisher = dh.FISHER(xdf, win[0])
xdf["FISHER_I"] = fisher["FISHER_I"].shift(1)
xdf = xdf.join(dh.BBANDS_STOP(xdf, win[1], 1.0).shift(1))
ha_df = dh.HEIKEN_ASHI(xdf, win[2]).shift(1)
xdf["HAopen"] = ha_df["HAopen"]
xdf["HAclose"] = ha_df["HAclose"]
ll = df.shape[0]
df["pos"] = pd.Series([0] * ll, index=df.index)
df["cost"] = pd.Series([0] * ll, index=df.index)
curr_pos = []
closed_trades = []
end_d = df.index[-1].date()
tradeid = 0
for dd in df.index:
mslice = df.ix[dd]
min_id = agent.get_min_id(dd)
d = dd.date()
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
df.ix[dd, "pos"] = pos
if np.isnan(mslice.BBSTOP_lower) or np.isnan(mslice.FISHER_I) or np.isnan(mslice.HAclose):
continue
end_trading = (min_id >= config["exit_min"]) and (d == end_d)
stop_loss = (pos > 0) and ((mslice.close < mslice.BBSTOP_lower) or (mslice.FISHER_I < 0))
stop_loss = stop_loss or ((pos < 0) and ((mslice.close > mslice.BBSTOP_upper) or (mslice.FISHER_I > 0)))
start_long = (mslice.FISHER_I > 0) and (mslice.HAclose > mslice.HAopen) and (mslice.BBSTOP_trend > 0)
start_short = (mslice.FISHER_I < 0) and (mslice.HAclose < mslice.HAopen) and (mslice.BBSTOP_trend < 0)
if pos != 0:
if stop_loss or end_trading:
curr_pos[0].close(mslice.close - misc.sign(pos) * offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
df.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
pos = 0
if (not end_trading) and (pos == 0):
if start_long and start_short:
print "warning: get both long and short signal, something is wrong!"
print mslice
continue
pos = (start_long == True) * unit - (start_short == True) * unit
if abs(pos) > 0:
# target = (start_long == True) * mslice.close +(start_short == True) * mslice.close
new_pos = strat.TradePos([mslice.contract], [1], pos, mslice.close, mslice.close)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + misc.sign(pos) * offset, dd)
curr_pos.append(new_pos)
df.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
df.ix[dd, "pos"] = pos
(res_pnl, ts) = backtest.get_pnl_stats(df, start_equity, marginrate, "m")
res_trade = backtest.get_trade_stats(closed_trades)
res = dict(res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def psar_test_sim( mdf, config):
close_daily = config['close_daily']
marginrate = config['marginrate']
offset = config['offset']
pos_update = config['pos_update']
pos_class = config['pos_class']
pos_args = config['pos_args']
proc_func = config['proc_func']
proc_args = config['proc_args']
start_equity = config['capital']
tcost = config['trans_cost']
unit = config['unit']
SL = config['stoploss']
chan = config['chan']
no_trade_set = config['no_trade_set']
ll = mdf.shape[0]
xdf = proc_func(mdf, **proc_args)
xdf['chan_h'] = pd.rolling_max(xdf.high, chan)
xdf['chan_l'] = pd.rolling_min(xdf.low, chan)
xdf['MA'] = pd.rolling_mean(xdf.close, chan)
psar_data = dh.PSAR(xdf, **config['sar_params'])
xdata = pd.concat([xdf['MA'], xdf['chan_h'], xdf['chan_l'], psar_data['PSAR_VAL'], psar_data['PSAR_DIR'], xdf['date_idx']],
axis=1, keys=['MA', 'chanH', 'chanL', 'psar', 'psar_dir', 'date'])
xdata = xdata.shift(1).fillna(0)
mdf = mdf.join(xdata, how = 'left').fillna(method='ffill')
mdf['pos'] = pd.Series([0]*ll, index = mdf.index)
mdf['cost'] = pd.Series([0]*ll, index = mdf.index)
curr_pos = []
closed_trades = []
end_d = mdf.index[-1].date
#prev_d = start_d - datetime.timedelta(days=1)
tradeid = 0
for dd in mdf.index:
mslice = mdf.ix[dd]
min_id = mslice.min_id
min_cnt = (min_id-300)/100 * 60 + min_id % 100 + 1
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, 'pos'] = pos
if (mslice.MA == 0) or (mslice.chanH == 0) or (mslice.chanL == 0) or (mslice.psar_dir ==0):
continue
if (min_id >= config['exit_min']) and (close_daily or (mslice.datetime.date == end_d)):
if (pos != 0):
curr_pos[0].close(mslice.close - misc.sign(pos) * offset , dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
elif min_id not in no_trade_set:
if (pos!=0) and pos_update:
curr_pos[0].update_price(mslice.close)
if (curr_pos[0].check_exit( mslice.close, SL * mslice.close )):
curr_pos[0].close(mslice.close-offset*misc.sign(pos), dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
long_close = ((mslice.low <= mslice.chanL) or (mslice.psar_dir < 0)) and (pos >0)
short_close = ((mslice.high >= mslice.chanH) or (mslice.psar_dir > 0)) and (pos <0)
close_price = mslice.close
if (short_close or long_close):
if (mslice.psar_dir > 0):
close_price = max(mslice.psar, mslice.open)
elif (mslice.psar_dir < 0):
close_price = min(mslice.psar, mslice.open)
curr_pos[0].close(mslice.close+offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
pos = 0
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
buy_trig = (mslice.high >= mslice.chanH) and (mslice.psar_dir > 0) and (pos ==0)
sell_trig = (mslice.low <= mslice.chanL) and (mslice.psar_dir < 0) and (pos == 0)
if buy_trig:
new_pos = pos_class([mslice.contract], [1], unit, mslice.close + offset, mslice.close + offset, **pos_args)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + offset, dd)
curr_pos.append(new_pos)
pos = unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
elif sell_trig:
new_pos = pos_class([mslice.contract], [1], -unit, mslice.close - offset, mslice.close - offset, **pos_args)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close - offset, dd)
curr_pos.append(new_pos)
pos = -unit
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
mdf.ix[dd, 'pos'] = pos
(res_pnl, ts) = backtest.get_pnl_stats( mdf, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats( closed_trades )
res = dict( res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def dual_thrust_sim(mdf, config):
close_daily = config["close_daily"]
marginrate = config["marginrate"]
offset = config["offset"]
k = config["k"]
f = config["f"]
start_equity = config["capital"]
win = config["win"]
multiplier = config["m"]
tcost = config["trans_cost"]
unit = config["unit"]
SL = config["stoploss"]
min_rng = config["min_range"]
ma_fast = config["MA_fast"]
ll = mdf.shape[0]
mdf["min_idx"] = pd.Series(1, index=mdf.index)
mdf.loc[mdf["min_id"] < 1500, "min_idx"] = 0
mdf["date_idx"] = mdf.index.date
xdf = mdf.groupby([mdf["date_idx"], mdf["min_idx"]]).apply(dh.ohlcsum).reset_index().set_index("datetime")
if win == -1:
tr = (
pd.concat([xdf.high - xdf.low, abs(xdf.close - xdf.close.shift(1))], join="outer", axis=1)
.max(axis=1)
.shift(1)
)
elif win == -2:
tr = pd.rolling_max(xdf.high, 2) - pd.rolling_min(xdf.low, 2)
elif win == 0:
tr = (
pd.concat(
[
(pd.rolling_max(xdf.high, 2) - pd.rolling_min(xdf.close, 2)) * multiplier,
(pd.rolling_max(xdf.close, 2) - pd.rolling_min(xdf.low, 2)) * multiplier,
xdf.high - xdf.close,
xdf.close - xdf.low,
],
join="outer",
axis=1,
)
.max(axis=1)
.shift(1)
)
else:
tr = (
pd.concat(
[
pd.rolling_max(xdf.high, win) - pd.rolling_min(xdf.close, win),
pd.rolling_max(xdf.close, win) - pd.rolling_min(xdf.low, win),
],
join="outer",
axis=1,
)
.max(axis=1)
.shift(1)
)
xdf["TR"] = tr
xdf["MA"] = pd.rolling_mean(xdf.close, ma_fast).shift(1)
ddf = pd.concat(
[xdf["TR"], xdf["MA"], xdf["open"], xdf["date_idx"]], axis=1, keys=["TR", "MA", "dopen", "date"]
).fillna(0)
mdf = mdf.join(ddf, how="left").fillna(method="ffill")
mdf["pos"] = pd.Series([0] * ll, index=mdf.index)
mdf["cost"] = pd.Series([0] * ll, index=mdf.index)
curr_pos = []
closed_trades = []
start_d = ddf.index[0]
end_d = mdf.index[-1].date()
# prev_d = start_d - datetime.timedelta(days=1)
tradeid = 0
for dd in mdf.index:
mslice = mdf.ix[dd]
min_id = agent.get_min_id(dd)
if len(curr_pos) == 0:
pos = 0
else:
pos = curr_pos[0].pos
mdf.ix[dd, "pos"] = pos
if mslice.TR == 0 or mslice.MA == 0:
continue
d_open = mslice.dopen
# if (prev_d < d):
# d_open = mslice.open
# else:
# d_open = dslice.open
rng = max(min_rng * d_open, k * mslice.TR)
if d_open <= 0:
continue
buytrig = d_open + rng
selltrig = d_open - rng
if mslice.MA > mslice.close:
buytrig += f * rng
elif mslice.MA < mslice.close:
selltrig -= f * rng
if (min_id >= config["exit_min"]) and (close_daily or (mslice.date == end_d)):
if pos != 0:
curr_pos[0].close(mslice.close - misc.sign(pos) * offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
pos = 0
else:
if (pos != 0) and (SL > 0):
curr_pos[0].trail_update(mslice.close)
if curr_pos[0].trail_check(mslice.close, SL * mslice.close):
curr_pos[0].close(mslice.close - offset * misc.sign(pos), dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
pos = 0
if (mslice.high >= buytrig) and (pos <= 0):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close + offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
new_pos = strat.TradePos([mslice.contract], [1], unit, mslice.close + offset, mslice.close + offset)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + offset, dd)
curr_pos.append(new_pos)
pos = unit
mdf.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
elif (mslice.low <= selltrig) and (pos >= 0):
if len(curr_pos) > 0:
curr_pos[0].close(mslice.close - offset, dd)
tradeid += 1
curr_pos[0].exit_tradeid = tradeid
closed_trades.append(curr_pos[0])
curr_pos = []
mdf.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
new_pos = strat.TradePos([mslice.contract], [1], -unit, mslice.close - offset, mslice.close - offset)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close - offset, dd)
curr_pos.append(new_pos)
pos = -unit
mdf.ix[dd, "cost"] -= abs(pos) * (offset + mslice.close * tcost)
mdf.ix[dd, "pos"] = pos
(res_pnl, ts) = backtest.get_pnl_stats(mdf, start_equity, marginrate, "m")
res_trade = backtest.get_trade_stats(closed_trades)
res = dict(res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
curr_pos = []
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
pos = 0
pos = (mslice.close>=mslice.upbnd) * unit -(mslice.close<=mslice.lowbnd) * unit
if abs(pos)>0:
target = min(mslice.close>=mslice.upbnd) * mslice.upbnd +(mslice.close<=mslice.lowbnd) * mslice.lowbnd
new_pos = strat.TradePos([mslice.contract], [1], pos, target, mslice.upbnd+mslice.lowbnd-target)
tradeid += 1
new_pos.entry_tradeid = tradeid
new_pos.open(mslice.close + misc.sign(pos)*offset, dd)
curr_pos.append(new_pos)
mdf.ix[dd, 'cost'] -= abs(pos) * (offset + mslice.close*tcost)
mdf.ix[dd, 'pos'] = pos
(res_pnl, ts) = backtest.get_pnl_stats( df, start_equity, marginrate, 'm')
res_trade = backtest.get_trade_stats( closed_trades )
res = dict( res_pnl.items() + res_trade.items())
return (res, closed_trades, ts)
def run_sim(asset, start_date, end_date):
config = {'nearby':1,
'rollrule':'-40b',
'marginrate':(0.05, 0.05),
'capital': 10000,
'offset': 0,
'trans_cost': 0.0,
'scaler': (2.0, 2.0),
'unit': 1,
'file_prefix': 'C:\\dev\\src\\ktlib\\pythonctp\\pyctp\\results\\Aberration_'}
#commod_list1= ['m','y','a','p','v','l','ru','rb','au','cu','al','zn','ag','i','j','jm'] #
