spot_range = np.arange(barrier - 0.1, strike + 0.1, 0.01)
barrier_npvs = []
call_npvs = []
put_npvs = []
portfolio_values = []
pnls = []
for s in spot_range:
underlying.setValue(s)
# barrier_npv = facevalue * exotic.barrier_npv_ql(evalDate, [], barrierType, barrier, payoff, exercise, process)
call_npv = facevalue * call.NPV()
put_npv = facevalue * put.NPV()
if s <= barrier:
portfolio_value = 0.0
barrier_npv = 0.0
else:
price = exotic.calculate_barrier_price(evaluation, barrier_option, [],
process, engineType)
barrier_npv = facevalue * price
portfolio_value = facevalue * portfolio.NPV()
pnl = portfolio_value - barrier_npv
barrier_npvs.append(barrier_npv)
call_npvs.append(call_npv)
put_npvs.append((put_npv))
portfolio_values.append(portfolio_value)
pnls.append(pnl / init_barrier)
print("%15s %25s %25s %25s %25s %25s" %
(s, round(barrier_npv, 2), round(call_npv, 2), round(put_npv, 2),
round(portfolio_value, 2), round(pnl / init_barrier, 2)))
df['Spot'] = spot_range
df['barrier_npv'] = barrier_npvs
df['call_npv'] = call_npvs
################Barrier Option Info#####################
#print('barrier/strike',barrier/strike)
optionBarrierEuropean = OptionBarrierEuropean(strike,maturitydt,optionType,barrier,barrierType)
barrier_option = optionBarrierEuropean.option_ql
hist_spots = []
#########################################################
# construct vol surface on last day's close prices.
evaluation = Evaluation(begDate, daycounter, calendar)
daily_close, black_var_surface, const_vol = get_vol_data(begDate,daycounter,calendar,contractType)
#print('init spot : ',daily_close)
underlying = ql.SimpleQuote(daily_close)
process_svi_h = evaluation.get_bsmprocess(daycounter, underlying, black_var_surface)
process_bs_h = evaluation.get_bsmprocess_cnstvol(daycounter, calendar, underlying, const_vol)
price_bs, delta_bs = exotic_util.calculate_barrier_price(evaluation, optionBarrierEuropean, hist_spots,
process_bs_h, engineType)
try:
price_svi, delta_svi = exotic_util.calculate_barrier_price(evaluation, optionBarrierEuropean, hist_spots,
process_svi_h, engineType)
except:
continue
init_svi = price_svi
init_bs = price_bs
init_spot = daily_close
tradingcost_svi = abs(delta_svi)*daily_close*fee
tradingcost_bs = abs(delta_bs)*daily_close*fee
cash_svi = price_svi - delta_svi*daily_close - tradingcost_svi
cash_bs = price_bs - delta_bs*daily_close - tradingcost_bs
replicate_svi = delta_svi*daily_close + cash_svi
replicate_bs = delta_bs*daily_close + cash_bs
init_replicate_svi = replicate_svi
paramset = calibrered_params_ts.get(to_dt_date(evalDate))
volSurface = SviVolSurface(evalDate, paramset, daycounter, calendar)
daily_close = svidata.spot
if daily_close <= barrier: break
maturity_dates = sorted(svidata.dataSet.keys())
svi = SviPricingModel(volSurface, daily_close, daycounter, calendar,
to_ql_dates(maturity_dates), ql.Option.Call,
contractType)
black_var_surface = svi.black_var_surface()
const_vol = estimated_vols.get(to_dt_date(evalDate))
# print(black_var_surface.blackVol(ttm,daily_close))
underlying = ql.SimpleQuote(daily_close)
process = evaluation.get_bsmprocess(daycounter, underlying,
black_var_surface)
barrier_price = exotic_util.calculate_barrier_price(
evaluation, barrier_option, hist_spots, process, engineType)
european_engine = ql.AnalyticEuropeanEngine(process)
call.setPricingEngine(european_engine)
put.setPricingEngine(european_engine)
# portfolio.setPricingEngine(european_engine)
portfolio_value = portfolio.NPV()
call_value = call.NPV()
put_value = put.NPV()
pnl_price = (portfolio_price - barrier_price) / init_barrier
pnl_value = (portfolio_value - barrier_price) / init_barrier
pnls_price.append(pnl_price)
pnls_value.append(pnl_value)
print(evalDate, pnl_price, pnl_value)
# print('spot',daily_close,strike)
# print(portfolio_price,portfolio_value)
# print(call_price,call_value)