def iv_at_the_money(dt_date, dt_last, name_code):
dict_iv_call = {}
dict_iv_put = {}
df_metrics = get_data.get_comoption_mktdata(dt_last, dt_date, name_code)
optionset = BaseOptionSet(df_metrics, rf=0.0)
optionset.init()
dt_maturity = optionset.select_maturity_date(0, 0)
call_list, put_list = optionset.get_options_list_by_moneyness_mthd1(
0, dt_maturity)
atm_call = optionset.select_higher_volume(call_list)
atm_put = optionset.select_higher_volume(put_list)
iv_call = atm_call.get_implied_vol() * 100
iv_put = atm_put.get_implied_vol() * 100
dict_iv_call.update({dt_last: iv_call})
dict_iv_put.update({dt_last: iv_put})
optionset.go_to(dt_date)
dt_maturity = optionset.select_maturity_date(0, 0)
call_list, put_list = optionset.get_options_list_by_moneyness_mthd1(
0, dt_maturity)
atm_call = optionset.select_higher_volume(call_list)
atm_put = optionset.select_higher_volume(put_list)
iv_call = atm_call.get_implied_vol() * 100
iv_put = atm_put.get_implied_vol() * 100
dict_iv_call.update({dt_date: iv_call})
dict_iv_put.update({dt_date: iv_put})
return dict_iv_call, dict_iv_put
def implied_vol_vw(df_metrics, df_res, dt_list_term_structure):
optionset = BaseOptionSet(df_metrics,rf=0.0)
optionset.init()
list_res_iv = []
iv_term_structure = []
while optionset.current_index < optionset.nbr_index:
dt_maturity = optionset.select_maturity_date(nbr_maturity=0, min_holding=min_holding)
iv_volume_weighted = optionset.get_volume_weighted_iv(dt_maturity)
list_res_iv.append({'date': optionset.eval_date, 'iv': iv_volume_weighted})
if optionset.eval_date in dt_list_term_structure:
mdt_2 = optionset.select_maturity_date(nbr_maturity=1, min_holding=0)
mdt_3 = optionset.select_maturity_date(nbr_maturity=2, min_holding=0)
iv_2 = optionset.get_volume_weighted_iv(mdt_2)
if mdt_3 is None:
iv_3 = None
else:
iv_3 = optionset.get_volume_weighted_iv(mdt_3)
iv_term_structure.append({'date': optionset.eval_date, 'iv1': iv_volume_weighted, 'iv2': iv_2, 'iv3': iv_3})
if not optionset.has_next(): break
optionset.next()
df_iv = pd.DataFrame(list_res_iv).sort_values(by='date', ascending=False).reset_index(drop=True)
df_res.loc[:, 'N:date'] = df_iv['date']
df_res.loc[:, 'O:iv'] = df_iv['iv']
df_res.loc[:, 'P'] = None
df_res.loc[:, 'Q'] = None
df_res.loc[:, 'R'] = None
df_res.loc[:, 'S'] = None
df_res.loc[:, 'T'] = None
print(df_iv)
df = pd.DataFrame(iv_term_structure)
df.to_csv('../data/' + name_code + '_iv_term_structure.csv')
return df_res
def iv_volume_weighted(dt_date, dt_last, name_code):
dict_iv = {}
df_metrics = get_data.get_comoption_mktdata(dt_last, dt_date, name_code)
optionset = BaseOptionSet(df_metrics)
optionset.init()
dt_maturity = optionset.select_maturity_date(0, 0)
iv_volume_weighted = optionset.get_volume_weighted_iv(dt_maturity) * 100
dict_iv.update({dt_last: iv_volume_weighted})
optionset.go_to(dt_date)
dt_maturity = optionset.select_maturity_date(0, 0)
iv_volume_weighted = optionset.get_volume_weighted_iv(dt_maturity) * 100
dict_iv.update({dt_date: iv_volume_weighted})
return dict_iv
def iv_htbr(dt_date, dt_last, name_code):
dict_iv = {}
df_metrics = get_data.get_comoption_mktdata(dt_last, dt_date, name_code)
optionset = BaseOptionSet(df_metrics, rf=0)
optionset.init()
dt_maturity = optionset.select_maturity_date(0, 0)
iv_curve_htbr = optionset.get_implied_vol_curves_htbr(dt_maturity)
call_list, put_list = optionset.get_options_list_by_moneyness_mthd1(
0, dt_maturity)
atm_k = call_list[0].applicable_strike()
iv = iv_curve_htbr[iv_curve_htbr[c.Util.AMT_APPLICABLE_STRIKE] == atm_k][
c.Util.PCT_IV_PUT_BY_HTBR].values[0] * 100
dict_iv.update({dt_last: iv})
optionset.go_to(dt_date)
dt_maturity = optionset.select_maturity_date(0, 0)
iv_curve_htbr = optionset.get_implied_vol_curves_htbr(dt_maturity)
call_list, put_list = optionset.get_options_list_by_moneyness_mthd1(
0, dt_maturity)
atm_k = call_list[0].applicable_strike()
iv = iv_curve_htbr[iv_curve_htbr[c.Util.AMT_APPLICABLE_STRIKE] == atm_k][
c.Util.PCT_IV_PUT_BY_HTBR].values[0] * 100
dict_iv.update({dt_date: iv})
return dict_iv
def implied_vol_vw(last_week, end_date, df_metrics, df_res, name_code):
m = 100
optionset = BaseOptionSet(df_metrics, rf=0.0)
optionset.init()
list_res_iv = []
while optionset.current_index < optionset.nbr_index:
dt_maturity = optionset.select_maturity_date(nbr_maturity=0,
min_holding=min_holding)
iv_volume_weighted = optionset.get_volume_weighted_iv(dt_maturity)
list_res_iv.append({
'date': optionset.eval_date,
'iv': iv_volume_weighted
})
if not optionset.has_next(): break
optionset.next()
df_iv = pd.DataFrame(list_res_iv).sort_values(
by='date', ascending=False).reset_index(drop=True)
df_res.loc[:, name_code + ':N:date'] = df_iv['date']
df_res.loc[:, name_code + ':O:iv'] = df_iv['iv'] * m
return df_res
def implied_vol_avg(last_week, end_date, df_metrics, df_res, name_code):
m = 100
optionset = BaseOptionSet(df_metrics, rf=0.03)
optionset.init()
list_res_iv = []
while optionset.current_index < optionset.nbr_index:
dt_maturity = optionset.select_maturity_date(nbr_maturity=0,
min_holding=min_holding)
list_atm_call, list_atm_put = optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=0, maturity=dt_maturity)
atm_call = optionset.select_higher_volume(list_atm_call)
atm_put = optionset.select_higher_volume(list_atm_put)
iv_call = atm_call.get_implied_vol()
iv_put = atm_put.get_implied_vol()
iv = (iv_put + iv_call) / 2.0
list_res_iv.append({'date': optionset.eval_date, 'iv': iv})
if not optionset.has_next(): break
optionset.next()
df_iv = pd.DataFrame(list_res_iv).sort_values(
by='date', ascending=False).reset_index(drop=True)
df_res.loc[:, name_code + ':N:date'] = df_iv['date']
df_res.loc[:, name_code + ':O:iv'] = df_iv['iv'] * m
return df_res
class Indexing():
def __init__(self, start_date, end_date):
df_metrics = option_data(start_date, end_date)
self.optionset = BaseOptionSet(df_metrics, rf=0.03)
self.optionset.init()
def fun_otm_quote(self, df):
if df[Util.AMT_APPLICABLE_STRIKE] > df['mid_k']:
quote = df['amt_call_quote']
elif df[Util.AMT_APPLICABLE_STRIKE] < df['mid_k']:
quote = df['amt_put_quote']
else:
quote = (df['amt_call_quote'] + df['amt_put_quote']) / 2.0
return quote
def fun_for_p1(self, df):
DK = df['amt_delta_k']
Q = df['amt_otm_quote']
K = df[Util.AMT_APPLICABLE_STRIKE]
res = Q * DK / K**2
return Q * DK / K**2
def fun_for_p2(self, df):
DK = df['amt_delta_k']
Q = df['amt_otm_quote']
K = df[Util.AMT_APPLICABLE_STRIKE]
F = df['F']
return 2 * (1 - math.log(K / F, math.e)) * Q * DK / K**2
def fun_for_p3(self, df):
DK = df['amt_delta_k']
Q = df['amt_otm_quote']
K = df[Util.AMT_APPLICABLE_STRIKE]
F = df['F']
return 3 * (2 * math.log(K / F, math.e) -
math.log(K / F, math.e)**2) * Q * DK / K**2
def fun_for_sigma(self, df):
DK = df['amt_delta_k']
Q = df['amt_otm_quote']
K = df[Util.AMT_APPLICABLE_STRIKE]
return Q * DK / K**2
def get_e1(self, F, K):
return -(1 + math.log(F / K, math.e) - F / K)
def get_e2(self, F, K):
return 2 * math.log(K / F, math.e) * (F / K - 1) + 0.5 * math.log(
K / F, math.e)**2
def get_e3(self, F, K):
return 3 * (math.log(K / F, math.e)**2) * (
(1.0 / 3.0) * math.log(K / F, math.e) + F / K - 1)
def get_S(self, p1, p2, p3):
res = (p3 - 3 * p1 * p2 + 2 * p1**3) / (p2 - p1**2)**1.5
return res
def get_T_quotes(self, df_mdt, eval_date):
df_call = df_mdt[df_mdt[Util.CD_OPTION_TYPE] == Util.STR_CALL].rename(
columns={Util.AMT_CLOSE: 'amt_call_quote'})
df_put = df_mdt[df_mdt[Util.CD_OPTION_TYPE] == Util.STR_PUT].rename(
columns={Util.AMT_CLOSE: 'amt_put_quote'})
df_call = df_call.drop_duplicates(
Util.AMT_APPLICABLE_STRIKE).reset_index(drop=True)
df_put = df_put.drop_duplicates(
Util.AMT_APPLICABLE_STRIKE).reset_index(drop=True)
df = pd.merge(df_call[[
'amt_call_quote', Util.AMT_APPLICABLE_STRIKE, Util.AMT_STRIKE
]],
df_put[['amt_put_quote', Util.AMT_APPLICABLE_STRIKE]],
how='inner',
on=Util.AMT_APPLICABLE_STRIKE)
# df = pd.concat([df_call[['amt_call_quote']], df_put[['amt_put_quote']]], axis=1, join='inner', verify_integrity=True)
df[Util.AMT_UNDERLYING_CLOSE] = df_put[
Util.AMT_UNDERLYING_CLOSE].values[0]
df['amt_cp_diff'] = abs(df['amt_call_quote'] - df['amt_put_quote'])
maturitydt = df_put[Util.DT_MATURITY].values[0]
df[Util.DT_MATURITY] = maturitydt
ttm = (
(maturitydt - eval_date).total_seconds() / 60.0) / (365.0 * 1440)
df['amt_ttm'] = ttm
df['amt_fv'] = math.exp(self.optionset.rf * (ttm))
df = df.sort_values(by=Util.AMT_APPLICABLE_STRIKE).reset_index(
drop=True)
dk = df[Util.AMT_APPLICABLE_STRIKE].diff(periods=2).dropna() / 2.0
dk.loc[1] = df.loc[1, Util.AMT_APPLICABLE_STRIKE] - df.loc[
0, Util.AMT_APPLICABLE_STRIKE]
dk.loc[len(df)] = df.loc[len(df) - 1,
Util.AMT_APPLICABLE_STRIKE] - df.loc[
len(df) - 2, Util.AMT_APPLICABLE_STRIKE]
dk = dk.sort_index()
dk = dk.reset_index(drop=True)
df['amt_delta_k'] = dk
return df
def forward_cboe(self, t_quotes, eval_date):
# ATM strike k0 -- First strike below the forward index level, F
# Forward price F -- F, by identifying the strike price at which the absolute difference
# between the call and put prices is smallest.
df = t_quotes.set_index(Util.AMT_APPLICABLE_STRIKE)
mid_k = df.sort_values(by='amt_cp_diff', ascending=True).index[0]
p_call = df.loc[mid_k, 'amt_call_quote']
p_put = df.loc[mid_k, 'amt_put_quote']
F = df.loc[mid_k, 'amt_fv'] * (p_call - p_put) + mid_k
df['k-f'] = df.index - F
if len(df[df['k-f'] < 0]) > 0:
K0 = df[df['k-f'] < 0].sort_values(by='amt_cp_diff',
ascending=True).index[0]
else:
K0 = df.sort_values(by='amt_cp_diff', ascending=True).index[0]
return mid_k, K0, F
""" K0 is the 1st strike below F0 """
def for_calculation(self, df, eval_date):
mid_k, k0, F = self.forward_cboe(df, eval_date)
ttm = df.loc[0, 'amt_ttm']
S = df.loc[0, 'amt_underlying_close']
implied_r = math.log(F / S, math.e) / ttm
self.implied_rf = implied_r
df['k0'] = k0
df['mid_k'] = mid_k
df['F'] = F
df['amt_otm_quote'] = df.apply(self.fun_otm_quote, axis=1)
return df
def calculate_S_for_skew(self, df):
k0 = df.loc[0, 'k0']
F = df.loc[0, 'F']
e1 = self.get_e1(F, k0)
e2 = self.get_e2(F, k0)
e3 = self.get_e3(F, k0)
df['for_p1'] = df.apply(self.fun_for_p1, axis=1)
df['for_p2'] = df.apply(self.fun_for_p2, axis=1)
df['for_p3'] = df.apply(self.fun_for_p3, axis=1)
fv = df.loc[0, 'amt_fv']
p1 = -fv * df['for_p1'].sum() + e1
p2 = fv * df['for_p2'].sum() + e2
p3 = fv * df['for_p3'].sum() + e3
S = self.get_S(p1, p2, p3)
SKEW = 100 - 10 * S
# S_r = self.get_S(-0.00173,0.003606,-0.00049)
# SKEW_r = 100-10*S_r
return S
def calculate_sigma_for_vix(self, df):
df['for_sigma'] = df.apply(self.fun_for_sigma, axis=1)
k0 = df.loc[0, 'k0']
F = df.loc[0, 'F']
T = df.loc[0, 'amt_ttm']
fv = df.loc[0, 'amt_fv']
v1 = (1.0 / T) * (F / k0 - 1)**2
# v1 = (F / K - 1) ** 2
sum = df['for_sigma'].sum()
sigma = (2.0 / T) * fv * sum - v1
# sigma = 2.0 * fv * sum - v1
return sigma
def calculate(self, eval_date):
df_daily_state = self.optionset.get_current_state()
mdt = self.optionset.get_maturities_list()[0]
if (mdt - self.optionset.eval_date).days <= 5:
mdt1 = self.optionset.get_maturities_list()[1]
mdt2 = self.optionset.get_maturities_list()[2]
else:
mdt1 = self.optionset.get_maturities_list()[0]
mdt2 = self.optionset.get_maturities_list()[1]
df_mdt1 = OptionUtil.get_df_by_mdt(df_daily_state, mdt1)
df_mdt2 = OptionUtil.get_df_by_mdt(df_daily_state, mdt2)
t_quotes1 = self.get_T_quotes(df_mdt1, eval_date)
t_quotes2 = self.get_T_quotes(df_mdt2, eval_date)
# t_quotes1.to_csv('t_quotes1.csv')
# t_quotes2.to_csv('t_quotes2.csv')
calculate1 = self.for_calculation(t_quotes1, eval_date)
calculate2 = self.for_calculation(t_quotes2, eval_date)
S1 = self.calculate_S_for_skew(calculate1)
S2 = self.calculate_S_for_skew(calculate2)
sigma1 = self.calculate_sigma_for_vix(calculate1)
sigma2 = self.calculate_sigma_for_vix(calculate2)
T1 = calculate1.loc[0, 'amt_ttm']
T2 = calculate2.loc[0, 'amt_ttm']
NT1 = (mdt1 - eval_date).total_seconds() / 60.0
NT2 = (mdt2 - eval_date).total_seconds() / 60.0
N30 = 30 * 1440.0
N365 = 365 * 1440.0
w = (NT2 - N30) / (NT2 - NT1)
skew = 100 - 10 * (w * S1 + (1 - w) * S2)
vix = 100 * math.sqrt(
(T1 * sigma1 * w + T2 * sigma2 * (1 - w)) * N365 / N30)
return vix, skew
def get_atm_options(self, maturity):
list_atm_call, list_atm_put = self.optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=0, maturity=maturity)
atm_call = self.optionset.select_higher_volume(list_atm_call)
atm_put = self.optionset.select_higher_volume(list_atm_put)
return atm_call, atm_put
def get_atm_iv_average(self, maturity):
atm_call, atm_put = self.get_atm_options(maturity)
iv_call = atm_call.get_implied_vol()
iv_put = atm_put.get_implied_vol()
iv_avg = (iv_call + iv_put) / 2
return iv_avg
def run(self):
self.df_res = pd.DataFrame()
print('=' * 120)
print("%10s %20s %20s %20s %20s %20s" %
('eval_date', 'vix', 'skew', 'iv_htr', 'iv_avg', 'htbr'))
print('-' * 120)
while self.optionset.current_index < self.optionset.nbr_index:
eval_date = self.optionset.eval_date
try:
maturity = self.optionset.select_maturity_date(
nbr_maturity, min_holding=min_holding)
iv_htr = self.optionset.get_atm_iv_by_htbr(maturity)
iv_avg = self.get_atm_iv_average(maturity)
htbr = self.optionset.get_htb_rate(maturity)
vix, skew = self.calculate(eval_date)
self.df_res.loc[eval_date, 'skew'] = skew
self.df_res.loc[eval_date, 'vix'] = vix
self.df_res.loc[
eval_date,
'50ETF'] = self.optionset.get_underlying_close()
self.df_res.loc[eval_date, 'htb_rate'] = htbr
self.df_res.loc[eval_date, 'iv_atm_htr'] = iv_htr
self.df_res.loc[eval_date, 'iv_atm_avg'] = iv_avg
print("%10s %20s %20s %20s %20s %20s" %
(eval_date, vix, skew, iv_htr, iv_avg, htbr))
except:
pass
if not self.optionset.has_next(): break
self.optionset.next()
class ParityArbitrage(object):
def __init__(self,name_code, df_option, df_etf=None, df_future_all=None,df_index=None):
self.name_code = name_code
self.df_option = df_option
self.df_etf = df_etf
self.df_future_all = df_future_all
self.df_index = df_index
self.rf = 0.03
self.m = 0.9
self.account = BaseAccount(c.Util.BILLION / 10,rf=self.rf)
self.unit = 50
self.min_holding = 6 # 50ETF与IH到期日相差5天
self.nbr_maturity = 0
self.rank = 3
self.slippage = 0
self.aggregate_costs = 0.5/100.0
self.cd_price = c.CdTradePrice.CLOSE
self.df_arbitrage_window = pd.DataFrame()
def init(self):
self.underlying = None
self.futureset = None
self.baseindex = None
self.optionset = BaseOptionSet(self.df_option)
self.optionset.init()
if self.name_code == c.Util.STR_50ETF:
if self.df_etf is not None:
self.underlying = BaseInstrument(self.df_etf) # 50ETF
self.underlying.init()
if self.df_future_all is not None:
self.futureset = BaseFutureSet(self.df_future_all) # IH
self.futureset.init()
self.future_unit_ratio = 1/1000.0
if self.df_index is not None:
self.baseindex = BaseInstrument(self.df_index) # SH50
self.baseindex.init()
else: # 商品期权
if self.df_future_all is not None:
self.futureset = BaseFutureSet(self.df_future_all) # IH
self.futureset.init()
self.future_unit_ratio = 1.0
# self.optionset = BaseOptionSet(self.df_option)
# self.optionset.init()
def update_sythetics(self):
if self.name_code == c.Util.STR_50ETF:
dt_maturity = self.optionset.select_maturity_date(nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
contract_month = self.optionset.get_dict_options_by_maturities()[dt_maturity][0].contract_month()
self.t_quote = self.optionset.get_T_quotes(dt_maturity, self.cd_price)
self.t_quote.loc[:, 'diff'] = abs(
self.t_quote.loc[:, c.Util.AMT_APPLICABLE_STRIKE] - self.t_quote.loc[:, c.Util.AMT_UNDERLYING_CLOSE])
self.t_quote.loc[:, 'rank'] = self.t_quote.index - self.t_quote['diff'].idxmin()
discount = c.PricingUtil.get_discount(self.optionset.eval_date, dt_maturity, self.rf)
self.t_quote.loc[:, 'sythetic_underlying'] = self.t_quote.loc[:, c.Util.AMT_CALL_QUOTE] \
- self.t_quote.loc[:,c.Util.AMT_PUT_QUOTE] \
+ self.t_quote.loc[:,c.Util.AMT_APPLICABLE_STRIKE] * discount
df_window = self.t_quote[(self.t_quote['rank']<=self.rank)&(self.t_quote['rank']>=-self.rank)] # 只考虑rank以内期权
self.row_max_sythetic = df_window.loc[df_window['sythetic_underlying'].idxmax()]
self.row_min_sythetic = df_window.loc[df_window['sythetic_underlying'].idxmin()]
self.df_arbitrage_window.loc[self.optionset.eval_date,'50etf'] = self.underlying.mktprice_close()
self.df_arbitrage_window.loc[self.optionset.eval_date,'sythetic_underlying_max'] = self.row_max_sythetic['sythetic_underlying']
self.df_arbitrage_window.loc[self.optionset.eval_date,'sythetic_underlying_min'] = self.row_min_sythetic['sythetic_underlying']
if self.futureset is not None:
future = self.futureset.select_future_by_contract_month(contract_month)
self.row_max_sythetic['future'] = future
if future is None:
return
self.basis_to_etf = future.mktprice_close() - self.underlying.mktprice_close()/self.future_unit_ratio
self.df_arbitrage_window.loc[self.optionset.eval_date, 'basis_to_etf'] = self.basis_to_etf
self.df_arbitrage_window.loc[self.optionset.eval_date, 'ih'] = future.mktprice_close()
if self.baseindex is not None:
self.basis_to_index = future.mktprice_close() - self.baseindex.mktprice_close()
self.tracking_error = self.underlying.mktprice_close()/self.future_unit_ratio - self.baseindex.mktprice_close()
self.df_arbitrage_window.loc[self.optionset.eval_date, 'basis_to_index'] = self.basis_to_index
self.df_arbitrage_window.loc[self.optionset.eval_date, 'tracking_error'] = self.tracking_error
self.df_arbitrage_window.loc[self.optionset.eval_date, 'index_50'] = self.baseindex.mktprice_close()
else:
dt_maturity = self.optionset.select_maturity_date(nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
contract_month = self.optionset.get_dict_options_by_maturities()[dt_maturity][0].contract_month()
self.t_quote = self.optionset.get_T_quotes(dt_maturity, self.cd_price)
self.t_quote.loc[:, 'diff'] = abs(
self.t_quote.loc[:, c.Util.AMT_APPLICABLE_STRIKE] - self.t_quote.loc[:, c.Util.AMT_UNDERLYING_CLOSE])
self.t_quote.loc[:, 'rank'] = self.t_quote.index - self.t_quote['diff'].idxmin()
discount = c.PricingUtil.get_discount(self.optionset.eval_date, dt_maturity, self.rf)
self.t_quote.loc[:, 'sythetic_underlying'] = self.t_quote.loc[:, c.Util.AMT_CALL_QUOTE] \
- self.t_quote.loc[:,c.Util.AMT_PUT_QUOTE] \
+ self.t_quote.loc[:,c.Util.AMT_APPLICABLE_STRIKE] * discount
df_window = self.t_quote[(self.t_quote['rank']<=self.rank)&(self.t_quote['rank']>=-self.rank)] # 只考虑rank以内期权
self.row_max_sythetic = df_window.loc[df_window['sythetic_underlying'].idxmax()]
self.row_min_sythetic = df_window.loc[df_window['sythetic_underlying'].idxmin()]
future = self.futureset.select_future_by_contract_month(contract_month)
self.underlying = future
self.df_arbitrage_window.loc[self.optionset.eval_date, 'underlying'] = self.underlying.mktprice_close()
self.df_arbitrage_window.loc[self.optionset.eval_date, 'sythetic_underlying_max'] = self.row_max_sythetic[
'sythetic_underlying']
self.df_arbitrage_window.loc[self.optionset.eval_date, 'sythetic_underlying_min'] = self.row_min_sythetic[
'sythetic_underlying']
def open_signal(self,cd_strategy):
if cd_strategy == 'box':
if (self.row_max_sythetic['sythetic_underlying'] - self.row_min_sythetic['sythetic_underlying'])/self.underlying.mktprice_close() > self.aggregate_costs:
df = pd.DataFrame(columns=['dt_date','id_instrument','base_instrument','long_short'])
df = self.short_sythetic(df)
df = self.long_sythetic(df)
return df
else:
return None
elif cd_strategy == 'conversion': # Converion : Short Sythetic, Long ETF
if (self.row_max_sythetic['sythetic_underlying'] - self.underlying.mktprice_close())/self.underlying.mktprice_close() > self.aggregate_costs:
df = pd.DataFrame(columns=['dt_date','id_instrument','base_instrument','long_short'])
df = self.short_sythetic(df)
df = self.long_etf(df)
return df
else:
return None
elif cd_strategy == 'conversion_ih': # Converion : Short Sythetic, Long IH # 主要布局IH负基差套利
if self.optionset.eval_date.month ==5: return None #5月由于股票集中现金分红不做空Synthetic
future = self.row_max_sythetic['future']
if future is None: return None
self.future = future
if (self.row_max_sythetic['sythetic_underlying']/self.future_unit_ratio - future.mktprice_close()-
self.df_arbitrage_window.loc[self.optionset.eval_date,'tracking_error'])/future.mktprice_close() > self.aggregate_costs:
df = pd.DataFrame(columns=['dt_date', 'id_instrument', 'base_instrument', 'long_short'])
df = self.short_sythetic(df)
df = self.long_ih(df,future)
return df
else:
return None
elif cd_strategy == 'ih_basis_arbitrage':
future = self.row_max_sythetic['future']
if future is None: return None
self.future = future
if self.df_arbitrage_window.loc[self.optionset.eval_date, 'basis_to_index'] < -self.aggregate_costs: # 期货贴水
df = pd.DataFrame(columns=['dt_date', 'id_instrument', 'base_instrument', 'long_short'])
df = self.short_sythetic(df)
df = self.long_ih(df,future)
return df
else:
return None
elif cd_strategy == 'may_effect': # Reverse: Long Sythetic, Short IH # 5-9月分红期
if self.optionset.eval_date.month ==5: #5月由于股票集中现金分红不做空Synthetic
df = pd.DataFrame(columns=['dt_date', 'id_instrument', 'base_instrument', 'long_short'])
df = self.long_sythetic(df)
df = self.short_ih(df)
return df
else:
return None
def close_signal(self,cd_strategy,df_position):
if cd_strategy == 'box':
if self.reverse_call.maturitydt() == self.optionset.eval_date or self.conversion_call.maturitydt() == self.optionset.eval_date :
return True
discount_r = c.PricingUtil.get_discount(self.optionset.eval_date, self.reverse_put.maturitydt(), self.rf)
discount_c = c.PricingUtil.get_discount(self.optionset.eval_date, self.conversion_put.maturitydt(), self.rf)
reverse_sythetic = self.reverse_call.mktprice_close()-self.reverse_put.mktprice_close()+self.reverse_put.applicable_strike()*discount_r # Longed
conversion_sythetic = self.conversion_call.mktprice_close()-self.conversion_put.mktprice_close()+self.conversion_put.applicable_strike()*discount_c # shorted
if conversion_sythetic <= reverse_sythetic:
return True
else:
return False
elif cd_strategy == 'conversion': # Short Sythetic, Long Underlying # 主要布局IH负基差套利
if self.conversion_call.maturitydt() == self.optionset.eval_date:
return True
discount_c = c.PricingUtil.get_discount(self.optionset.eval_date, self.conversion_put.maturitydt(), self.rf)
conversion_sythetic = self.conversion_call.mktprice_close() - self.conversion_put.mktprice_close() + self.conversion_put.applicable_strike() * discount_c # shorted
if conversion_sythetic/self.future_unit_ratio <= self.underlying.mktprice_close():
return True
else:
return False
elif cd_strategy == 'conversion_ih': # Short Sythetic, Long IH # 主要布局IH负基差套利
if self.conversion_call.maturitydt() == self.optionset.eval_date or self.future.maturitydt() == self.optionset.eval_date:
return True
discount_c = c.PricingUtil.get_discount(self.optionset.eval_date, self.conversion_put.maturitydt(), self.rf)
conversion_sythetic = self.conversion_call.mktprice_close() - self.conversion_put.mktprice_close() + self.conversion_put.applicable_strike() * discount_c # shorted
if conversion_sythetic/self.future_unit_ratio <= self.future.mktprice_close():
return True
else:
return False
elif cd_strategy == 'ih_basis_arbitrage':
if self.df_arbitrage_window.loc[self.optionset.eval_date, 'basis_to_index'] >= 0:
return True
else:
return False
elif cd_strategy == 'may_effect': # Reverse: Long Sythetic, Short IH # 5-9月分红期
if self.optionset.eval_date.month !=5: #5月由于股票集中现金分红不做空Synthetic
return True
else:
return False
def open_excute(self,open_signal):
if open_signal is None:
return False
else:
fund_per_unit = open_signal['fund_requirement'].sum()
unit = np.floor(self.account.cash*self.m/fund_per_unit)
for (idx,row) in open_signal.iterrows():
option = row['base_instrument']
order = self.account.create_trade_order(option, row['long_short'], unit*row['unit_ratio'],
cd_trade_price=self.cd_price)
record = option.execute_order(order, slippage=self.slippage)
self.account.add_record(record, option)
print(self.optionset.eval_date, ' open position')
return True
def close_excute(self):
self.close_out()
print(self.optionset.eval_date, ' close position')
return True
# else:
# for (idx,row) in close_signal.iterrows():
# option = row['base_instrument']
# order = self.account.create_trade_order(option, row['long_short'], row['unit'],
# cd_trade_price=self.cd_price)
# record = option.execute_order(order, slippage=self.slippage)
# self.account.add_record(record, option)
# return True
def close_out(self):
close_out_orders = self.account.creat_close_out_order(cd_trade_price=c.CdTradePrice.CLOSE)
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(execution_record, self.account.dict_holding[order.id_instrument])
def short_sythetic(self,df):
# Short Sythetic
self.conversion_call = self.optionset.get_baseoption_by_id(self.row_max_sythetic[c.Util.ID_CALL])
fund_requirement = self.conversion_call.get_fund_required(c.LongShort.SHORT)
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'C_call',
'id_instrument': self.row_max_sythetic[c.Util.ID_CALL],
'base_instrument': self.conversion_call,
'long_short': c.LongShort.SHORT,
'fund_requirement': fund_requirement,
'cashflow_t0': self.conversion_call.mktprice_close() * self.conversion_call.multiplier(),
'unit_ratio' : 1},
ignore_index=True)
self.conversion_put = self.optionset.get_baseoption_by_id(self.row_max_sythetic[c.Util.ID_PUT])
fund_requirement = self.conversion_put.get_fund_required(c.LongShort.LONG)
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'C_put',
'id_instrument': self.row_max_sythetic[c.Util.ID_PUT],
'base_instrument': self.conversion_put,
'long_short': c.LongShort.LONG,
'fund_requirement': fund_requirement,
'cashflow_t0': -self.conversion_put.mktprice_close() * self.conversion_put.multiplier(),
'unit_ratio' : 1},
ignore_index=True)
return df
def long_sythetic(self,df):
# Reverse : Long Sythetic
self.reverse_call = self.optionset.get_baseoption_by_id(self.row_min_sythetic[c.Util.ID_CALL])
fund_requirement = self.reverse_call.get_fund_required(c.LongShort.LONG)
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'R_call',
'id_instrument': self.row_min_sythetic[c.Util.ID_CALL],
'base_instrument': self.reverse_call,
'long_short': c.LongShort.LONG,
'fund_requirement': fund_requirement,
'cashflow_t0': -self.reverse_call.mktprice_close() * self.reverse_call.multiplier()},
ignore_index=True)
self.reverse_put = self.optionset.get_baseoption_by_id(self.row_min_sythetic[c.Util.ID_PUT])
fund_requirement = self.reverse_put.get_fund_required(c.LongShort.SHORT)
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'R_put',
'id_instrument': self.row_min_sythetic[c.Util.ID_PUT],
'base_instrument': self.reverse_put,
'long_short': c.LongShort.SHORT,
'fund_requirement': fund_requirement,
'cashflow_t0': self.reverse_put.mktprice_close() * self.reverse_put.multiplier()},
ignore_index=True)
return df
def long_etf(self,df):
unit_ratio = self.conversion_put.multiplier()
fund_requirement = self.conversion_put.multiplier() * self.underlying.mktprice_close()
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'underlying',
'id_instrument': self.underlying.id_instrument(),
'base_instrument': self.underlying,
'long_short': c.LongShort.LONG,
'fund_requirement': fund_requirement,
'cashflow_t0': -self.underlying.mktprice_close() * self.underlying.multiplier()*unit_ratio,
'unit_ratio' : unit_ratio},
ignore_index=True)
return df
def long_ih(self,df,future):
unit_ratio = self.conversion_put.multiplier()/future.multiplier()/1000.0
fund_requirement = future.mktprice_close()*future.multiplier()*unit_ratio
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'underlying',
'id_instrument': future.id_instrument(),
'base_instrument': future,
'long_short': c.LongShort.LONG,
'fund_requirement': fund_requirement,
'cashflow_t0': -future.mktprice_close() * future.multiplier()*unit_ratio,
'unit_ratio' : unit_ratio},
ignore_index=True)
return df
def short_ih(self,df):
unit_ratio = self.reverse_put.multiplier()/self.future.multiplier()/1000.0
fund_requirement = self.future.mktprice_close()*self.future.multiplier()*unit_ratio
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'underlying',
'id_instrument': self.future.id_instrument(),
'base_instrument': self.future,
'long_short': c.LongShort.SHORT,
'fund_requirement': fund_requirement,
'cashflow_t0': -self.future.mktprice_close() * self.future.multiplier()*unit_ratio,
'unit_ratio' : unit_ratio},
ignore_index=True)
return df
def back_test(self, cd_strategy):
# TODO: DIVIDEND
empty_position = True
df_position = None
while self.optionset.has_next():
# if self.optionset.eval_date == datetime.date(2015,5,18):
# print('')
self.update_sythetics()
if empty_position:
df_position = self.open_signal(cd_strategy)
empty_position = not self.open_excute(df_position)
elif self.close_signal(cd_strategy,df_position):
empty_position = self.close_excute()
# if isinstance(self.underlying,BaseFutureCoutinuous):
# self.underlying.shift_contract_month(self.account,self.slippage)
self.account.daily_accounting(self.optionset.eval_date)
self.optionset.next()
self.underlying.next()
if self.futureset is not None: self.futureset.next()
if self.baseindex is not None: self.baseindex.next()
# print(self.optionset.eval_date)
return self.account
def back_test_comdty(self, cd_strategy):
empty_position = True
df_position = None
while self.optionset.has_next():
# if self.optionset.eval_date == datetime.date(2015,5,18):
# print('')
self.update_sythetics()
if empty_position:
df_position = self.open_signal(cd_strategy)
empty_position = not self.open_excute(df_position)
elif self.close_signal(cd_strategy,df_position):
empty_position = self.close_excute()
# if isinstance(self.underlying,BaseFutureCoutinuous):
# self.underlying.shift_contract_month(self.account,self.slippage)
self.account.daily_accounting(self.optionset.eval_date)
self.optionset.next()
self.futureset.next()
# if self.baseindex is not None: self.baseindex.next()
# print(self.optionset.eval_date)
return self.account
iv_put = atm_put.get_implied_vol()
iv_avg = (iv_call + iv_put) / 2
return iv_avg
pu = PlotUtil()
start_date = datetime.date(2018, 9, 12)
end_date = datetime.date(2018, 9, 13)
nbr_maturity = 0
min_holding = 8
df_daily = get_data.get_comoption_mktdata(start_date, end_date, Util.STR_SR)
optionset = BaseOptionSet(df_data=df_daily, rf=0.015)
optionset.init()
# optionset.go_to(end_date)
maturity = optionset.select_maturity_date(nbr_maturity,
min_holding=min_holding)
iv_htr = optionset.get_atm_iv_by_htbr(maturity)
iv_avg = get_atm_iv_average(optionset, maturity)
htbr = optionset.get_htb_rate(maturity)
print('iv_htr : ', iv_htr)
print('iv_avg : ', iv_avg)
print('htb rate : ', htbr)
# curve = optionset.get_implied_vol_curves(maturity)
# curve_htbr = optionset.get_implied_vol_curves_htbr(maturity)
curve_otm = optionset.get_otm_implied_vol_curve(maturity)
# curve_htbr[Util.PCT_IV_CALL_BY_HTBR] = curve_htbr[Util.PCT_IV_CALL_BY_HTBR].apply(lambda x: None if x<0.05 else x)
# curve_htbr[Util.PCT_IV_PUT_BY_HTBR] = curve_htbr[Util.PCT_IV_PUT_BY_HTBR].apply(lambda x: None if x<0.05 else x)
curve_otm[Util.PCT_IV_OTM_BY_HTBR] = curve_otm[Util.PCT_IV_OTM_BY_HTBR].apply(
print(d1, d2, d)
df_metrics = df_metrics[df_metrics[c.Util.DT_DATE] >= d].reset_index(drop=True)
df_c1 = df_future_c1_daily[
df_future_c1_daily[c.Util.DT_DATE] >= d].reset_index(drop=True)
optionset = BaseOptionSet(df_metrics)
optionset.init()
d1 = optionset.eval_date
df_c1 = df_c1.rename(columns={c.Util.ID_INSTRUMENT: 'id_future'})
df_c1.loc[:, c.Util.ID_INSTRUMENT] = name_code
hedging = SytheticOption(df_c1, frequency=c.FrequentType.DAILY)
hedging.init()
account = BaseAccount(init_fund=c.Util.BILLION, leverage=1.0, rf=0.03)
maturity1 = optionset.select_maturity_date(nbr_maturity=0, min_holding=15)
empty_position = True
unit_p = None
unit_c = None
atm_strike = None
buy_write = c.BuyWrite.WRITE
print(optionset.eval_date, hedging.eval_date)
while optionset.eval_date <= end_date:
if account.cash <= 0: break
if maturity1 > end_date: # Final close out all.
close_out_orders = account.creat_close_out_order()
for order in close_out_orders:
execution_record = account.dict_holding[
order.id_instrument].execute_order(
order,
slippage=0,
import datetime
""""""
name_code = c.Util.STR_M
core_id = 'm_1901'
end_date = datetime.date(2018, 9, 7)
last_week = datetime.date(2018, 8, 31)
start_date = last_week
dt_histvol = start_date - datetime.timedelta(days=200)
min_holding = 5
df_metrics = get_data.get_comoption_mktdata(start_date, end_date, name_code)
""" T-quote IV """
optionset = BaseOptionSet(df_metrics, rf=0)
optionset.init()
optionset.go_to(end_date)
dt_maturity = optionset.select_maturity_date(0, min_holding)
call_list, put_list = optionset.get_options_list_by_moneyness_mthd1(
0, dt_maturity)
atm_call = optionset.select_higher_volume(call_list)
atm_put = optionset.select_higher_volume(put_list)
print('atm call iv: ', atm_call.get_implied_vol())
print('atm put iv: ', atm_put.get_implied_vol())
print('atm strike: ', atm_put.strike())
t_quote = optionset.get_T_quotes(dt_maturity)
ivs_c1 = optionset.get_call_implied_vol_curve(dt_maturity)
ivs_p1 = optionset.get_put_implied_vol_curve(dt_maturity)
ivs_c2 = optionset.get_call_implied_vol_curve_htbr(dt_maturity)
ivs_p2 = optionset.get_put_implied_vol_curve_htbr(dt_maturity)
iv_curve = optionset.get_implied_vol_curves(dt_maturity)
def implied_vol_avg(df_metrics, df_res, dt_list_term_structure, name_code):
if name_code == c.Util.STR_CU:
m = 100
else:
m = 1
optionset = BaseOptionSet(df_metrics, rf=0.03)
optionset.init()
list_res_iv = []
iv_term_structure = []
while optionset.current_index < optionset.nbr_index:
dt_maturity = optionset.select_maturity_date(nbr_maturity=0,
min_holding=min_holding)
list_atm_call, list_atm_put = optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=0, maturity=dt_maturity)
atm_call = optionset.select_higher_volume(list_atm_call)
atm_put = optionset.select_higher_volume(list_atm_put)
iv_call = atm_call.get_implied_vol()
iv_put = atm_put.get_implied_vol()
iv = (iv_put + iv_call) / 2.0
list_res_iv.append({'date': optionset.eval_date, 'iv': iv})
if optionset.eval_date in dt_list_term_structure:
mdt_2 = optionset.select_maturity_date(nbr_maturity=1,
min_holding=0)
list_atm_call, list_atm_put = optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=0, maturity=mdt_2)
atm_call = optionset.select_higher_volume(list_atm_call)
atm_put = optionset.select_higher_volume(list_atm_put)
iv_call = atm_call.get_implied_vol()
iv_put = atm_put.get_implied_vol()
iv_2 = (iv_put + iv_call) / 2.0
mdt_3 = optionset.select_maturity_date(nbr_maturity=2,
min_holding=0)
if mdt_3 is None:
iv_3 = None
else:
list_atm_call, list_atm_put = optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=0, maturity=mdt_3)
atm_call = optionset.select_higher_volume(list_atm_call)
atm_put = optionset.select_higher_volume(list_atm_put)
iv_call = atm_call.get_implied_vol()
iv_put = atm_put.get_implied_vol()
iv_3 = (iv_put + iv_call) / 2.0
iv_term_structure.append({
'date': optionset.eval_date,
'iv1': iv,
'iv2': iv_2,
'iv3': iv_3
})
if not optionset.has_next(): break
optionset.next()
df_iv = pd.DataFrame(list_res_iv).sort_values(
by='date', ascending=False).reset_index(drop=True)
df_res.loc[:, 'N:date'] = df_iv['date']
df_res.loc[:, 'O:iv'] = df_iv['iv'] * m
df_res.loc[:, 'P'] = None
df_res.loc[:, 'Q'] = None
df_res.loc[:, 'R'] = None
df_res.loc[:, 'S'] = None
df_res.loc[:, 'T'] = None
print(df_iv)
df = pd.DataFrame(iv_term_structure)
df.to_csv('../data/' + name_code + '_iv_term_structure.csv')
return df_res
class HedgeIndexByOptions(object):
def __init__(self,
df_baseindex,
df_option_metrics,
df_c1=None,
df_all=None,
cd_direction_timing='ma',
cd_strategy='bull_spread',
cd_volatility='close_std',
cd_short_ma='ma_5',
cd_long_ma='ma_60',
cd_std='std_10'):
self.min_holding = 20
self.slippage = 0
self.nbr_maturity = 0
self.moneyness_rank = 0
self.cd_trade_price = c.CdTradePrice.VOLUME_WEIGHTED
# self.cd_trade_price = c.CdTradePrice.CLOSE
if df_c1 is None:
dt_start = max(df_option_metrics[c.Util.DT_DATE].values[0],
df_baseindex[c.Util.DT_DATE].values[0])
self.end_date = min(df_option_metrics[c.Util.DT_DATE].values[-1],
df_baseindex[c.Util.DT_DATE].values[-1])
df_metrics = df_option_metrics[
df_option_metrics[c.Util.DT_DATE] >= dt_start].reset_index(
drop=True)
df_baseindex = df_baseindex[
df_baseindex[c.Util.DT_DATE] >= dt_start].reset_index(
drop=True)
self.invst_portfolio = BaseInstrument(
df_baseindex) # e.g., top 50 low volatility index
self.invst_portfolio.init()
else:
dt_start = max(df_option_metrics[c.Util.DT_DATE].values[0],
df_baseindex[c.Util.DT_DATE].values[0],
df_c1[c.Util.DT_DATE].values[0])
self.end_date = min(df_option_metrics[c.Util.DT_DATE].values[-1],
df_baseindex[c.Util.DT_DATE].values[-1],
df_c1[c.Util.DT_DATE].values[-1])
df_metrics = df_option_metrics[
df_option_metrics[c.Util.DT_DATE] >= dt_start].reset_index(
drop=True)
df_baseindex = df_baseindex[
df_baseindex[c.Util.DT_DATE] >= dt_start].reset_index(
drop=True)
df_c1 = df_c1[df_c1[c.Util.DT_DATE] >= dt_start].reset_index(
drop=True)
df_all = df_all[df_all[c.Util.DT_DATE] >= dt_start].reset_index(
drop=True)
self.invst_portfolio = BaseFutureCoutinuous(
df_c1, df_futures_all_daily=df_all
) # e.g., top 50 low volatility index
self.invst_portfolio.init()
self.optionset = BaseOptionSet(df_metrics)
self.index = BaseInstrument(df_baseindex)
self.optionset.init()
self.index.init()
self.account = BaseAccount(init_fund=c.Util.BILLION,
leverage=1.0,
rf=0.03)
self.prepare_timing(df_baseindex)
self.cd_direction_timing = cd_direction_timing
self.cd_strategy = cd_strategy
self.cd_volatility = cd_volatility
self.cd_short_ma = cd_short_ma
self.cd_long_ma = cd_long_ma
self.cd_std = cd_std
self.dict_strategy = {}
self.nbr_timing = 0
self.nbr_stop_loss = 0
self.nvp_adjustment = 0
self.sl_npv_high_point = 1.0
self.strategy_pause = False
def prepare_timing(self, df_index):
df_index['ma_3'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=3).shift()
df_index['ma_5'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=5).shift()
df_index['ma_10'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=10).shift()
df_index['ma_15'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=15).shift()
df_index['ma_20'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=20).shift()
df_index['ma_30'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=30).shift()
df_index['ma_40'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=40).shift()
df_index['ma_50'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=50).shift()
df_index['ma_60'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=60).shift()
df_index['ma_120'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=120).shift()
df_index['std_5'] = c.Statistics.standard_deviation(
df_index[c.Util.AMT_CLOSE], n=5).shift()
df_index['std_10'] = c.Statistics.standard_deviation(
df_index[c.Util.AMT_CLOSE], n=10).shift()
df_index['std_15'] = c.Statistics.standard_deviation(
df_index[c.Util.AMT_CLOSE], n=15).shift()
df_index['std_20'] = c.Statistics.standard_deviation(
df_index[c.Util.AMT_CLOSE], n=20).shift()
df_index['ma_3-20'] = df_index['ma_3'] - df_index['ma_20']
self.df_timing = df_index.set_index(c.Util.DT_DATE)
def open_signal(self):
if self.cd_direction_timing == 'ma':
return self.open_position_ma()
def close_signal(self):
if self.cd_direction_timing == 'ma':
return self.close_position_ma()
def stop_loss_beg(self, drawdown, P_mdd):
if drawdown.loc[self.optionset.eval_date, c.Util.DRAWDOWN] <= P_mdd:
return True
def stop_loss_end(self, drawdown, P_mdd):
if drawdown.loc[
self.optionset.eval_date,
c.Util.PORTFOLIO_NPV] >= self.account.account[
c.Util.PORTFOLIO_NPV].values[-1] + self.nvp_adjustment:
self.nvp_adjustment = drawdown.loc[
self.optionset.eval_date,
c.Util.PORTFOLIO_NPV] - self.account.account[
c.Util.PORTFOLIO_NPV].values[-1]
self.nbr_stop_loss += 1
print(self.optionset.eval_date, ' stop loss end ')
print(self.nvp_adjustment,
self.account.account[c.Util.PORTFOLIO_NPV].values[-1],
drawdown.loc[self.optionset.eval_date, c.Util.PORTFOLIO_NPV])
return True
def strategy(self, cd_price=c.CdPriceType.OPEN):
if self.cd_strategy == 'bull_spread':
if self.cd_volatility == 'close_std':
dt_date = self.optionset.eval_date
std_close = self.df_timing.loc[dt_date, self.cd_std]
k_short = self.index.mktprice_open() - std_close
put_long, put_short = self.bull_spread(k_short, cd_price)
return {
c.LongShort.SHORT: put_short,
c.LongShort.LONG: put_long
}
def shift(self):
if self.cd_strategy == 'bull_spread':
return self.shift_bull_spread()
def open_position_ma(self):
dt_date = self.optionset.eval_date
if dt_date not in self.df_timing.index:
return False
ma_5 = self.df_timing.loc[dt_date, self.cd_short_ma]
ma_60 = self.df_timing.loc[dt_date, self.cd_long_ma]
if ma_5 < ma_60:
return True
else:
return False
def close_position_ma(self):
dt_date = self.optionset.eval_date
dt_maturity = None
for option in self.account.dict_holding.values():
if isinstance(option, BaseOption) and option is not None:
dt_maturity = option.maturitydt()
break
if dt_maturity is not None and (dt_maturity - dt_date).days <= 5:
return True
ma_5 = self.df_timing.loc[dt_date, self.cd_short_ma]
ma_60 = self.df_timing.loc[dt_date, self.cd_long_ma]
if ma_5 >= ma_60:
print(self.optionset.eval_date)
self.nbr_timing += 1
return True
else:
return False
def bull_spread(self, k_short, cd_price=c.CdPriceType.OPEN):
maturity = self.optionset.select_maturity_date(
nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
xx, list_put0 = self.optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=self.moneyness_rank,
maturity=maturity,
cd_price=cd_price)
put_long = self.optionset.select_higher_volume(list_put0)
# if put_long is None:
# xxx, list_put0 = optionset.get_options_list_by_moneyness_mthd1(moneyness_rank=0,
# maturity=maturity,
# cd_price=c.CdPriceType.OPEN)
# put_long = optionset.select_higher_volume(list_put0)
put_short = self.optionset.select_higher_volume(
self.optionset.get_option_closest_strike(c.OptionType.PUT, k_short,
maturity))
if put_short is not None:
if put_short.strike() >= (k_short + put_long.strike()) / 2.0:
put_short = None
elif put_short.id_instrument() == put_long.id_instrument():
xx, list_put1 = self.optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=-1, maturity=maturity, cd_price=cd_price)
put_short = self.optionset.select_higher_volume(list_put1)
# put_short = None
return put_long, put_short
def shift_bull_spread(self):
option_short = self.dict_strategy[c.LongShort.SHORT]
option_long = self.dict_strategy[c.LongShort.LONG]
if option_short is None:
return self.strategy()
else:
if self.index.mktprice_last_close() <= (option_long.strike() +
option_short.strike()) / 2:
return self.strategy()
else:
return None
def excute(self, dict_strategy, cd_trade_price=None):
if cd_trade_price is None:
cd_trade_price = self.cd_trade_price
if dict_strategy is None: return
for long_short in dict_strategy.keys():
option = dict_strategy[long_short]
if option is None:
continue
elif long_short in self.dict_strategy.keys() and self.dict_strategy[long_short] is not None \
and option.id_instrument() == self.dict_strategy[long_short].id_instrument():
continue
unit = self.unit_index / option.multiplier()
order = self.account.create_trade_order(
option, long_short, unit, cd_trade_price=cd_trade_price)
record = option.execute_order(order, slippage=self.slippage)
self.account.add_record(record, option)
self.dict_strategy = dict_strategy
def close_options(self):
for option in self.account.dict_holding.values():
if isinstance(option, BaseOption):
order = self.account.create_close_order(
option, cd_trade_price=self.cd_trade_price)
record = option.execute_order(order, slippage=self.slippage)
self.account.add_record(record, option)
self.dict_strategy = {}
def close_out(self):
close_out_orders = self.account.creat_close_out_order(
cd_trade_price=c.CdTradePrice.CLOSE)
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
def back_test(self):
self.unit_index = np.floor(self.account.cash /
self.index.mktprice_close() /
self.index.multiplier())
unit_portfolio = np.floor(self.account.cash /
self.invst_portfolio.mktprice_close() /
self.invst_portfolio.multiplier())
order_index = self.account.create_trade_order(
self.invst_portfolio,
c.LongShort.LONG,
unit_portfolio,
cd_trade_price=c.CdTradePrice.CLOSE)
record_index = self.invst_portfolio.execute_order(
order_index, slippage=self.slippage)
self.account.add_record(record_index, self.invst_portfolio)
empty_position = True
init_index = self.index.mktprice_close()
init_portfolio = self.invst_portfolio.mktprice_close()
base_npv = []
index_npv = []
while self.optionset.eval_date <= self.end_date:
# if self.optionset.eval_date == datetime.date(2016,5,20):
# print('')
# print(self.optionset.eval_date)
if self.optionset.eval_date >= self.end_date: # Final close out all.
close_out_orders = self.account.creat_close_out_order()
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
self.account.daily_accounting(self.optionset.eval_date)
base_npv.append(self.invst_portfolio.mktprice_close() /
init_portfolio)
index_npv.append(self.index.mktprice_close() / init_index)
print(self.optionset.eval_date, ' close out ')
break
if not empty_position:
if self.close_signal():
self.close_options()
empty_position = True
else:
strategy = self.shift()
if strategy is not None:
self.close_options()
self.excute(strategy)
if empty_position and self.open_signal():
self.excute(self.strategy())
empty_position = False
#TODO:移仓换月
if isinstance(self.invst_portfolio, BaseFutureCoutinuous):
self.invst_portfolio.shift_contract_month(
self.account, self.slippage)
self.account.daily_accounting(self.optionset.eval_date)
self.account.account.loc[self.optionset.eval_date,
'unit_index'] = self.unit_index
self.account.account.loc[
self.optionset.eval_date,
'close_index'] = self.index.mktprice_close()
# print(self.optionset.eval_date,estimated_npv1,estimated_npv2,estimated_npv3,self.account.account.loc[self.optionset.eval_date,c.Util.PORTFOLIO_NPV])
base_npv.append(self.invst_portfolio.mktprice_close() /
init_portfolio)
index_npv.append(self.index.mktprice_close() / init_index)
# print(self.invst_portfolio.eval_date, self.account.account.loc[self.optionset.eval_date,c.Util.PORTFOLIO_NPV],
# self.invst_portfolio.mktprice_close() / init_index)
if not self.optionset.has_next(): break
self.optionset.next()
self.index.next()
self.invst_portfolio.next()
self.account.account['base_npv'] = base_npv
self.account.account['index_npv'] = index_npv
# active_npv = self.df_index[self.df_index[c.Util.DT_DATE]<=self.optionset.eval_date].reset_index(drop=True)
# self.account.account['active_npv'] = active_npv[c.Util.AMT_CLOSE]
self.account.nbr_timing = self.nbr_timing
# print(self.account.account.loc[self.invst_portfolio.eval_date,c.Util.PORTFOLIO_NPV])
return self.account
def back_test_with_stop_loss(self, drawdown, P_mdd):
self.P_mdd = P_mdd
self.unit_index = np.floor(self.account.cash /
self.index.mktprice_close() /
self.index.multiplier())
order_index = self.account.create_trade_order(
self.index,
c.LongShort.LONG,
self.unit_index,
cd_trade_price=c.CdTradePrice.CLOSE)
record_index = self.index.execute_order(order_index,
slippage=self.slippage)
self.account.add_record(record_index, self.index)
empty_position = True
init_index = self.index.mktprice_close()
base_npv = []
stop_loss_paused = False
while self.optionset.eval_date <= self.end_date:
# if self.optionset.eval_date == datetime.date(2016,5,20):
# print('')
# print(self.optionset.eval_date)
if self.optionset.eval_date >= self.end_date: # Final close out all.
close_out_orders = self.account.creat_close_out_order()
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
self.account.daily_accounting(self.optionset.eval_date)
base_npv.append(self.index.mktprice_close() / init_index)
print(self.optionset.eval_date, ' close out ')
break
# Option Hedge
if not stop_loss_paused:
if not empty_position:
if self.close_signal():
self.close_all_options()
empty_position = True
else:
strategy = self.shift()
if strategy is not None:
self.close_all_options()
self.excute(strategy)
if empty_position and self.open_signal():
self.excute(self.strategy())
empty_position = False
estimated_npv = self.account.estimate_npv()
self.sl_npv_high_point = max(self.sl_npv_high_point, estimated_npv)
# if self.account.account.loc[self.optionset.eval_date, c.Util.DRAWDOWN]>= 0.0:
# self.P_mdd = P_mdd
# 止损控制
if (estimated_npv - self.sl_npv_high_point
) / self.sl_npv_high_point < self.P_mdd:
self.close_out()
self.sl_npv_high_point = estimated_npv
self.strategy_npv_paused = drawdown.loc[
self.optionset.eval_date, c.Util.PORTFOLIO_NPV]
print(self.optionset.eval_date, 'stop loss',
self.sl_npv_high_point, self.P_mdd)
self.account.daily_accounting(self.optionset.eval_date, False)
base_npv.append(self.index.mktprice_close() / init_index)
if not self.optionset.has_next(): break
self.optionset.next()
self.index.next()
stop_loss_paused = True
empty_position = True
# self.P_mdd = -0.02
continue
if stop_loss_paused:
strategy_npv = drawdown.loc[self.optionset.eval_date,
c.Util.PORTFOLIO_NPV]
# 止损后空仓
# if strategy_npv <= self.strategy_npv_paused:
if (strategy_npv - self.strategy_npv_paused
) / self.strategy_npv_paused < 0.01:
self.account.daily_accounting(self.optionset.eval_date)
base_npv.append(self.index.mktprice_close() / init_index)
if not self.optionset.has_next(): break
self.optionset.next()
self.index.next()
continue
# 止损信号解除
else:
order_index = self.account.create_trade_order(
self.index,
c.LongShort.LONG,
self.unit_index,
cd_trade_price=c.CdTradePrice.CLOSE)
record_index = self.index.execute_order(
order_index, slippage=self.slippage)
self.account.add_record(record_index, self.index)
stop_loss_paused = False
self.nbr_stop_loss += 1
print(self.optionset.eval_date, 'stop loss end')
# if empty_position and self.open_signal():
# self.excute(self.strategy(cd_price=c.CdPriceType.CLOSE),cd_trade_price=c.CdTradePrice.CLOSE)
# empty_position = False
# 每日结算
self.account.daily_accounting(self.optionset.eval_date)
base_npv.append(self.index.mktprice_close() / init_index)
if not self.optionset.has_next(): break
self.optionset.next()
self.index.next()
self.account.account['base_npv'] = base_npv
# active_npv = self.df_index[self.df_index[c.Util.DT_DATE] <= self.optionset.eval_date].reset_index(drop=True)
# self.account.account['active_npv'] = active_npv[c.Util.AMT_CLOSE]
self.account.nbr_timing = self.nbr_timing
self.account.nbr_stop_loss = self.nbr_stop_loss
return self.account
class NakedShort(object):
def __init__(self,
df_metrics,
df_baseindex=None,
cd_strategy='naked_put',
id_baseindex=c.Util.STR_INDEX_300SH,
cd_marutity_days=3):
self.start_date = df_metrics[c.Util.DT_DATE].values[0]
self.end_date = df_metrics[c.Util.DT_DATE].values[-1]
if df_baseindex is None:
df_baseindex = get_data.get_index_mktdata(self.start_date,
self.end_date,
c.Util.STR_INDEX_300SH)
self.min_holding = 20
self.init_fund = c.Util.BILLION
self.slippage = 0
self.m = 1 # 期权notional倍数
if cd_strategy == 'short_straddle':
self.m = 0.5
self.moneyness_rank = -4
self.nbr_maturity = 0
self.cd_trade_price = c.CdTradePrice.VOLUME_WEIGHTED
self.account = BaseAccount(init_fund=c.Util.BILLION,
leverage=1.0,
rf=0.03)
self.optionset = BaseOptionSet(df_metrics)
self.optionset.init()
self.index = BaseInstrument(df_baseindex)
self.index.init()
self.cd_strategy = cd_strategy
self.cd_maturity_days = cd_marutity_days
self.init_index = self.index.mktprice_close()
# w.start()
# TODO: 统一 check dt_first; 将base_npv写入accout
def close_signal(self):
dt_maturity = None
for option in self.account.dict_holding.values():
if isinstance(option, BaseOption) and option is not None:
dt_maturity = option.maturitydt()
break
# t = w.tdayscount(self.optionset.eval_date.strftime("%Y-%m-%d"), dt_maturity.strftime("%Y-%m-%d"), "").Data[0][0]
t = c.QuantlibUtil.get_business_between(self.optionset.eval_date,
dt_maturity)
if t <= self.cd_maturity_days:
# if (dt_maturity - self.optionset.eval_date).days <= self.cd_maturity_days:
return True
else:
return False
def close_out(self):
close_out_orders = self.account.creat_close_out_order(
cd_trade_price=c.CdTradePrice.CLOSE)
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
def close_all_options(self):
for option in self.account.dict_holding.values():
if isinstance(option, BaseOption):
order = self.account.create_close_order(
option, cd_trade_price=self.cd_trade_price)
record = option.execute_order(order, slippage=self.slippage)
self.account.add_record(record, option)
def strategy(self):
if self.cd_strategy == 'short_straddle':
return self.short_straddle()
elif self.cd_strategy == 'short_put':
return self.short_put()
elif self.cd_strategy == 'short_call':
return self.short_call()
def short_straddle(self):
maturity1 = self.optionset.select_maturity_date(
nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
list_atm_call, list_atm_put = self.optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=self.moneyness_rank,
maturity=maturity1,
cd_price=c.CdPriceType.OPEN)
atm_call = self.optionset.select_higher_volume(list_atm_call)
atm_put = self.optionset.select_higher_volume(list_atm_put)
if atm_call is None or atm_put is None:
return
else:
return [atm_call, atm_put]
def short_put(self):
maturity1 = self.optionset.select_maturity_date(
nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
list_atm_call, list_atm_put = self.optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=self.moneyness_rank,
maturity=maturity1,
cd_price=c.CdPriceType.OPEN)
atm_put = self.optionset.select_higher_volume(list_atm_put)
if atm_put is None:
return
else:
return [atm_put]
def short_call(self):
maturity1 = self.optionset.select_maturity_date(
nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
list_atm_call, list_atm_put = self.optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=self.moneyness_rank,
maturity=maturity1,
cd_price=c.CdPriceType.OPEN)
atm_call = self.optionset.select_higher_volume(list_atm_call)
if atm_call is None:
return
else:
return [atm_call]
def excute(self, strategy):
if strategy is None:
return True
else:
pv = self.account.portfolio_total_value
for option in strategy:
unit = np.floor(
np.floor(pv / option.strike()) /
option.multiplier()) * self.m
order = self.account.create_trade_order(
option,
c.LongShort.SHORT,
unit,
cd_trade_price=self.cd_trade_price)
record = option.execute_order(order, slippage=self.slippage)
self.account.add_record(record, option)
return False
def back_test(self):
empty_position = True
index_npv = []
while self.optionset.eval_date <= self.end_date:
# print(optionset.eval_date)
# if self.account.cash <= 0: break
if self.optionset.eval_date >= self.end_date: # Final close out all.
self.close_out()
self.account.daily_accounting(self.optionset.eval_date)
index_npv.append(self.index.mktprice_close() / self.init_index)
break
# 平仓
if not empty_position and self.close_signal():
self.close_all_options()
empty_position = True
# 开仓
if empty_position:
empty_position = self.excute(self.strategy())
self.account.daily_accounting(self.optionset.eval_date)
index_npv.append(self.index.mktprice_close() / self.init_index)
# print(self.optionset.eval_date,self.account.account.loc[self.optionset.eval_date,c.Util.PORTFOLIO_NPV])
if not self.optionset.has_next(): break
self.optionset.next()
self.index.next()
self.account.account['index_npv'] = index_npv
class VolTrading(object):
def __init__(self, start_date, end_date, df_metrics, df_vol,
df_future_c1_daily, df_futures_all_daily):
self.min_holding = 20
self.slippage = 0
self.nbr_maturity = 0
self.moneyness_rank = 0
self.m_notional = 1
self.rf = 0.03
self.n_premium_std = 90 #用于计算权利金溢价1倍标准差的数据期限
self.n_hv = 20 # 用与期权期限相匹配的历史波动率期限
self.n_close_by_maturity = 5
self.min_premium = 2.0 / 100.0 # 对冲成本对应的开平仓最低隐含波动率溢价
self.n_llt = 5
self.cd_option_price = c.CdTradePrice.CLOSE
self.cd_future_price = c.CdTradePrice.CLOSE
self.cd_price = c.CdPriceType.CLOSE
self.start_date = start_date
self.end_date = end_date
self.df_metrics = df_metrics
self.df_vol = df_vol
self.df_f_c1 = df_future_c1_daily
self.df_f_all = df_futures_all_daily
def init(self):
df_future_histvol = self.df_f_c1.copy()
df_future_histvol['amt_hv'] = histvol.hist_vol(
df_future_histvol[c.Util.AMT_CLOSE], n=self.n_hv)
self.dt_start = max(self.df_f_c1[c.Util.DT_DATE].values[0],
self.df_metrics[c.Util.DT_DATE].values[0])
self.end_date = min(self.df_f_c1[c.Util.DT_DATE].values[-1],
self.df_metrics[c.Util.DT_DATE].values[-1])
self.df_metrics = self.df_metrics[
self.df_metrics[c.Util.DT_DATE] >= self.dt_start].reset_index(
drop=True)
self.df_f_c1 = self.df_f_c1[
self.df_f_c1[c.Util.DT_DATE] >= self.dt_start].reset_index(
drop=True)
self.df_f_all = self.df_f_all[
self.df_f_all[c.Util.DT_DATE] >= self.dt_start].reset_index(
drop=True)
self.df_vol = pd.merge(self.df_vol,
df_future_histvol[[c.Util.DT_DATE, 'amt_hv']],
on=c.Util.DT_DATE).set_index(c.Util.DT_DATE)
self.optionset = BaseOptionSet(self.df_metrics)
self.optionset.init()
self.hedging = SytheticOption(self.df_f_c1,
rf=self.rf,
df_futures_all_daily=self.df_f_all)
self.hedging.init()
self.hedging.amt_option = 1 / 1000 # 50ETF与IH点数之比
self.account = BaseAccount(init_fund=c.Util.BILLION, rf=self.rf)
self.prepare_timing()
def prepare_timing(self):
self.timing_hviv()
self.timing_llt()
def timing_hviv(self):
self.df_vol['amt_premium'] = self.df_vol[
c.Util.PCT_IMPLIED_VOL] - self.df_vol['amt_hv']
self.df_vol['amt_1std'] = c.Statistics.standard_deviation(
self.df_vol['amt_premium'], n=self.n_premium_std)
self.df_vol['amt_2std'] = 2 * c.Statistics.standard_deviation(
self.df_vol['amt_premium'], n=self.n_premium_std)
self.df_vol['percentile_95'] = c.Statistics.percentile(
self.df_vol[c.Util.PCT_IMPLIED_VOL], n=252, percent=0.95)
def timing_llt(self):
self.df_vol['LLT_' + str(self.n_llt)] = LLT(
self.df_vol[c.Util.PCT_IMPLIED_VOL], self.n_llt)
self.df_vol['LLT_signal_' +
str(self.n_llt)] = self.df_vol['LLT_' +
str(self.n_llt)].diff()
def open_signal(self):
pass
def close_signal(self):
pass
def open_signal_llt(self):
dt_date = self.optionset.eval_date
if dt_date not in self.df_vol.index:
return False
if self.df_vol.loc[dt_date, 'LLT_signal_5'] < 0: # 隐含波动率处于下行区间
return True
else:
return False
def close_signal_llt(self):
dt_date = self.optionset.eval_date
if dt_date not in self.df_vol.index:
return False
if self.df_vol.loc[dt_date, 'LLT_signal_5'] > 0: # 隐含波动率处于上行区间
return True
else:
return False
def open_signal_ivhv(self):
dt_date = self.optionset.eval_date
if dt_date not in self.df_vol.index:
return False
amt_premium = self.df_vol.loc[dt_date, 'amt_premium']
amt_1std = self.df_vol.loc[dt_date, 'amt_1std']
if amt_premium > amt_1std and amt_premium > self.min_premium: # 隐含波动率相比历史波动率具有一定溢价
return True
else:
return False
def close_signal_ivhv(self):
dt_date = self.optionset.eval_date
amt_premium = self.df_vol.loc[dt_date, 'amt_premium']
if amt_premium <= self.min_premium:
return True
else:
return False
def close_signal_maturity(self):
dt_maturity = None
for option in self.account.dict_holding.values():
if isinstance(option, BaseOption) and option is not None:
dt_maturity = option.maturitydt()
break
if (dt_maturity -
self.optionset.eval_date).days <= self.n_close_by_maturity:
return True
else:
return False
def strategy(self):
return self.short_straddle()
def short_straddle(self):
maturity = self.optionset.select_maturity_date(
nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
list_atm_call, list_atm_put = self.optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=self.moneyness_rank,
maturity=maturity,
cd_price=self.cd_price)
atm_call = self.optionset.select_higher_volume(list_atm_call)
atm_put = self.optionset.select_higher_volume(list_atm_put)
if atm_call is None or atm_put is None:
return
else:
return [atm_call, atm_put]
def excute(self, strategy):
if strategy is None:
return False
else:
pv = self.account.portfolio_total_value
self.option_holding = {}
for option in strategy:
unit = np.floor(
np.floor(pv / option.strike()) /
option.multiplier()) * self.m_notional
order = self.account.create_trade_order(
option,
c.LongShort.SHORT,
unit,
cd_trade_price=self.cd_option_price)
record = option.execute_order(order,
slippage_rate=self.slippage)
self.account.add_record(record, option)
self.option_holding.update({option: unit})
return True
def close_out(self):
close_out_orders = self.account.creat_close_out_order(
cd_trade_price=c.CdTradePrice.CLOSE)
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage_rate=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
def close_out_1(self):
for option in self.account.dict_holding.values():
if isinstance(option, BaseOption):
order = self.account.create_close_order(
option, cd_trade_price=self.cd_option_price)
else:
order = self.account.create_close_order(
option, cd_trade_price=self.cd_future_price)
record = option.execute_order(order, slippage_rate=self.slippage)
self.account.add_record(record, option)
# TODO: Use Delta Bound Model
def delta_hedge(self):
option1 = list(self.option_holding.keys())[0]
iv_htbr = self.optionset.get_iv_by_otm_iv_curve(
dt_maturity=option1.maturitydt(),
strike=option1.applicable_strike())
options_delta = 0
for option in self.option_holding.keys():
unit = self.option_holding[option]
options_delta += unit * option.get_delta(
iv_htbr) * option.multiplier()
hedge_unit = self.hedging.get_hedge_rebalancing_unit(
options_delta, c.BuyWrite.WRITE)
self.hedging.synthetic_unit += -hedge_unit
if hedge_unit > 0:
long_short = c.LongShort.LONG
else:
long_short = c.LongShort.SHORT
order_u = self.account.create_trade_order(
self.hedging,
long_short,
hedge_unit,
cd_trade_price=self.cd_future_price)
record_u = self.hedging.execute_order(order_u,
slippage_rate=self.slippage)
self.account.add_record(record_u, self.hedging)
# print('')
def back_test(self):
empty_position = True
while self.optionset.eval_date <= self.end_date:
# if self.optionset.eval_date == datetime.date(2017, 1, 19):
# print('')
if self.optionset.eval_date >= self.end_date: # Final close out all.
self.close_out()
self.account.daily_accounting(self.optionset.eval_date)
print(self.optionset.eval_date, ' close out ')
print(
self.optionset.eval_date, self.hedging.eval_date,
self.account.account.loc[self.optionset.eval_date,
c.Util.PORTFOLIO_NPV],
int(self.account.cash))
break
# 标的移仓换月
if self.hedging.close_old_contract_month(
self.account, self.slippage,
cd_price=self.cd_future_price):
self.hedging.synthetic_unit = 0
# 平仓
if not empty_position:
if self.close_signal():
self.close_out_1()
self.hedging.synthetic_unit = 0
empty_position = True
# 开仓
if empty_position and self.open_signal():
s = self.strategy()
empty_position = not self.excute(s)
# Delta hedge
if not empty_position:
self.delta_hedge()
self.account.daily_accounting(self.optionset.eval_date)
if not self.optionset.has_next():
break
self.optionset.next()
self.hedging.next()
return self.account