def get_smile_for_differents_rho(rho_s: Types.ndarray, epsilon: float,
k: float, v0: float, theta: float,
european_options: List[EuropeanOption]):
heston_iv = []
no_rho_s = len(rho_s)
for i in range(0, no_rho_s):
rho_i = rho_s[i]
rho_i_iv = []
for option in european_options:
price = option.get_analytic_value(
0.0,
theta,
rho_i,
k,
epsilon,
v0,
0.0,
model_type=Types.ANALYTIC_MODEL.HESTON_MODEL_REGULAR,
compute_greek=False)
if option._option_type == TypeEuropeanOption.CALL:
iv = implied_volatility(price, option._spot, option._strike,
option._delta_time, 0.0, 0.0, 'c')
else:
iv = implied_volatility(price, option._spot, option._strike,
option._delta_time, 0.0, 0.0, 'p')
rho_i_iv.append(iv)
heston_iv.append((rho_i, rho_i_iv))
return heston_iv
def greeks(pos,
ticker,
target_value,
flag,
S,
K,
t0,
t1,
r,
div,
px='',
IV_only=False):
if flag == 'C':
call_put = 'Call'
else:
call_put = "Put"
d1 = datetime.strptime(t1, '%Y%m%d')
d0 = datetime.strptime(t0, '%Y%m%d')
delta = d1 - d0
delta_annual = delta.days / 365
sigma = BSM.implied_volatility(target_value, S, K, delta_annual, r, div,
flag.lower())
if IV_only == False:
risk_parameters = {
'delta_spot': 0.02,
'delta_vol': 0.02,
'delta_rf_rate': 0.02,
'delta_time': 1
} # TODO Fix with next quantsbin release
equity_o = qbdp.EqOption(option_type=call_put,
strike=K,
expiry_date=t1,
expiry_type='American')
engine = equity_o.engine(model="Binomial",
spot0=S,
pricing_date=t0,
rf_rate=r,
yield_div=div,
volatility=sigma)
greeks = engine.risk_parameters(**risk_parameters)
greeks['Contract'] = [ticker, t1, str(K), flag]
greeks['IV'] = sigma
if px == '':
greeks['Avg px'] = target_value
else:
greeks['Avg px'] = px
greeks['DTE'] = delta.days
greeks['pos'] = pos
# print(greeks)
return greeks
else:
return sigma
def greeks(target_value, flag, S, K, t1, t0, r, div, key=None):
if flag == 'C':
call_put = 'Call'
else:
call_put = "Put"
d1 = datetime.datetime.strptime(t1, '%Y%m%d')
d0 = datetime.datetime.strptime(t0, '%Y%m%d')
delta = d1 - d0
delta_annual = delta.days / 365
sigma = BSM.implied_volatility(target_value, S, K, delta_annual, r, div,
flag.lower())
risk_parameters = {
'delta_spot': 0.02,
'delta_vol': 0.02,
'delta_rf_rate': 0.02,
'delta_time': 1
} # TODO Fix with next quantsbin release
# equity_o = qbdp.EqOption(option_type=call_put, strike=K, expiry_date=t1, expiry_type='American')
# engine = equity_o.engine(model="Binomial", spot0=S, pricing_date=t0,
# rf_rate=r, yield_div=div, volatility=sigma)
# greeks = engine.risk_parameters(**risk_parameters)
# greeks['key'] = key
# print(greeks)
return sigma
def test_implied_volatility(self):
while self.tdi.has_next():
row = self.tdi.next_row()
S, K, t, r, sigma = row['S'], row['K'], row['t'], row['R'], row[
'v']
C, P = black_scholes_merton('c', S, K, t, r, sigma,
q), black_scholes_merton(
'p', S, K, t, r, sigma, q)
try:
iv = implied_volatility(C, S, K, t, r, q, 'c')
self.assertAlmostEqual(sigma, iv, delta=0.0001)
except:
print('could not calculate iv for ', C, S, K, t, r, 'c')
iv = implied_volatility(P, S, K, t, r, q, 'p')
self.assertTrue(
iv == 0.0) if iv == 0.0 else self.assertAlmostEqual(
sigma, iv, delta=0.001)
def get_iv(row, side):
try:
iv = implied_volatility(
row['{}_price'.format(side)] * row['index_price'],
row['index_price'], row['strike'], row['until_expiry'],
row['interest_rate'], row['q'], row['flag'])
iv = round(100 * iv, 2)
except Exception as e:
print(e)
iv = np.nan
return iv
def get_vetor_iv_cev(nu: float, alpha: float, T: float):
# Smile curve with cev
mesh_t = Mesh(uniform_mesh, 100, 0.0, T)
mesh_x = LnUnderlyingMesh(0.0, 0.0, nu, f0, T, 0.999, uniform_mesh, 200)
log_diffusion = partial(LocalVolFunctionals.log_cev_diffusion,
beta=alpha - 1,
sigma=nu)
cev_pde = PDE.from_ipde_terms(LN_FORWARD_LOCAL_VOL_PDE(log_diffusion))
k_s = np.arange(f0 - 4.0, f0 + 4.0, 0.5)
# k_s = [f0]
tc_s = [TerminalCondition(partial(f_ln_payoff, k=k_i)) for k_i in k_s]
bc = Zero_Laplacian_BC()
operator_exp = PDEOperators.LinearPDEOperator(mesh_x, cev_pde, bc)
operator_impl = PDEOperators.LinearPDEOperator(mesh_x, cev_pde, bc)
operators = [operator_exp, operator_impl]
pde_price = []
for tc_i in tc_s:
pd_solver = PDESolvers.FDSolver(mesh_t, mesh_x, operators,
SchemeType.CRANK_NICOLSON,
BoundaryConditionType.ZERO_DIFFUSION,
tc_i)
pd_solver.solver()
f = interp1d(mesh_x.get_points(),
pd_solver._u_grid[:, 0],
kind='linear',
fill_value='extrapolate')
pde_price.append(float(f(np.log(f0))))
# Hagan approximation
expansion_hagan = ExpansionLocVol.hagan_loc_vol(
lambda t: nu, lambda x: np.power(x, alpha),
lambda x: alpha * np.power(x, alpha - 1.0), lambda x: alpha *
(alpha - 1.0) * np.power(x, alpha - 2.0))
# Compute the iv
no_elements = len(pde_price)
# From hagan
iv_hagan = []
iv_fd = []
z_s = []
for i in range(0, no_elements):
z_s.append(np.log(k_s[i] / f0))
iv_fd.append(
implied_volatility(pde_price[i], f0, k_s[i], T, 0.0, 0.0, 'c'))
for i in range(0, no_elements):
iv_hagan.append(expansion_hagan.get_implied_vol(T, f0, k_s[i]))
return z_s, iv_fd, iv_hagan
def calculate(cls,
S,
K,
t,
V_market,
r=RISK_FREE_INTEREST_RATE,
q=0,
flag='c'):
try:
return IV.implied_volatility(V_market, S, K, t, r, q, flag)
except VolatilityValueException:
return 0.0
def btnClicked(self):
price = float(self.ui.StPrice.toPlainText())
strike = float(self.ui.Strike.toPlainText())
days = float(self.ui.Days.toPlainText()) / 365
rate = float(self.ui.intrate.toPlainText())
divd = float(self.ui.dividend.toPlainText())
cp = self.ui.corp.toPlainText()
optprice1 = float(self.ui.optprice.toPlainText())
vol = BSvol.implied_volatility(optprice1, price, strike, days, rate,
divd, cp)
delt = BSgreeksN.delta(cp, price, strike, days, rate, vol, divd)
vega = BSgreeksN.vega(cp, price, strike, days, rate, vol, divd)
gamma = BSgreeksN.gamma(cp, price, strike, days, rate, vol, divd)
theta = BSgreeksN.theta(cp, price, strike, days, rate, vol, divd)
self.ui.volatility.setText(str(vol))
self.ui.Delta1.setText(str(delt))
self.ui.Theta1.setText(str(theta))
self.ui.Gamma1.setText(str(gamma))
self.ui.Vega1.setText(str(vega))
r_t=0.0,
x=x0,
v=v0,
theta=theta,
rho=rho,
k=k,
epsilon=epsilon,
b=b2,
u=u2)
cos_price_heston = COSRepresentation.get_european_option_price(
TypeEuropeanOption.CALL, a, b, 128, k_s, cf_heston)
iv_smile_heston = []
for j in range(0, no_strikes):
iv_smile_heston.append(
implied_volatility(cos_price_heston[j], f0, f0, T[i], 0.0, 0.0,
'c'))
plt.plot(k_s,
iv_smile_heston,
label='T=%s' % T[i],
linestyle='--',
color='black',
marker=markers[i])
plt.ylim([0.0, 2.0])
plt.xlabel('K')
plt.legend()
plt.show()
for i in range(0, no_strikes):
index_normal_option = np.searchsorted(
np.array(map_output[Types.SABR_OUTPUT.TIMES]), T)
mc_normal_options_price = normal_options[i].get_price_control_variate(
map_output[Types.SABR_OUTPUT.PATHS][:, -1],
map_output[Types.SABR_OUTPUT.INTEGRAL_VARIANCE_PATHS])
options[i].update_forward_start_date_index(
np.array(map_output[Types.SABR_OUTPUT.TIMES]))
mc_option_price = options[i].get_price_control_variate(
map_output[Types.SABR_OUTPUT.PATHS],
map_output[Types.SABR_OUTPUT.INTEGRAL_VARIANCE_PATHS])
implied_vol_forward.append(
implied_volatility(mc_option_price[0] / f0, 1.0, strikes[i],
T - d_t_forward, 0.0, 0.0, 'c'))
implied_vol_spot.append(
implied_volatility(mc_normal_options_price[0] / f0, 1.0, strikes[i], T,
0.0, 0.0, 'c'))
plt.plot(strikes,
implied_vol_forward,
label='forward smile SABR',
color='black',
linestyle='--')
plt.plot(strikes,
implied_vol_spot,
label='spot smile SABR',
color='black',
linestyle='--',
marker='.')
def ivol(self, S, pr):
return bsi.implied_volatility(pr, S, self.K, option.time_exp[self.exp],
self.rate, 0., self.flag)
EuropeanOption(f0 * (1.0 + shift_spot), 1.0, TypeSellBuy.BUY, TypeEuropeanOption.CALL, f0, d_i))
# outputs
smile_atm_mc = []
for i in range(0, no_dt_s):
rnd_generator.set_seed(seed)
map_output = LocalVolEngine.get_path_multi_step(0.0, dt[i], f0, no_paths, no_time_steps,
Types.TYPE_STANDARD_NORMAL_SAMPLING.ANTITHETIC,
local_vol_mc, rnd_generator)
# implied vol by MC and asymptotic expansion
mc_option_price = options[i].get_price(map_output[Types.LOCAL_VOL_OUTPUT.PATHS][:, -1])
mc_option_price_right = options_shift_right[i].get_price(map_output[Types.LOCAL_VOL_OUTPUT.PATHS][:, -1])
mc_option_price_left = options_shift_left[i].get_price(map_output[Types.LOCAL_VOL_OUTPUT.PATHS][:, -1])
implied_vol_atm = implied_volatility(mc_option_price[0], f0, f0, dt[i], 0.0, 0.0, 'c')
implied_vol_atm_shift_left = implied_volatility(mc_option_price_left[0], f0, f0 * (1.0 - shift_spot), dt[i], 0.0, 0.0, 'c')
implied_vol_atm_shift_right = implied_volatility(mc_option_price_right[0], f0, f0 * (1.0 + shift_spot), dt[i], 0.0, 0.0, 'c')
smile_atm_mc.append((implied_vol_atm_shift_right - 2.0 * implied_vol_atm +
implied_vol_atm_shift_left) / (shift_spot * shift_spot))
asymptotic_limit = (sigma / 6.0) * np.power(beta - 1.0, 2.0) * np.exp((beta - 1.0) * np.log(f0))
plt.plot(dt, smile_atm_mc, label='smile atm CEV', color='black', linestyle='--')
plt.plot(dt, np.ones(len(dt)) * asymptotic_limit, label='asymptotic limit',
color='black', marker='.', linestyle='--')
plt.xlabel('T')
plt.legend()
plt.show()
model_type=Types.ANALYTIC_MODEL.HESTON_MODEL_ATTARI,
compute_greek=False)
price_rho_zero = options[i].get_analytic_value(
0.0,
theta,
0.0,
k,
epsilon,
v0,
0.0,
model_type=Types.ANALYTIC_MODEL.HESTON_MODEL_ATTARI,
compute_greek=False)
iv_vol_rho.append(
implied_volatility(price_rho_no_zero, f0, strikes[i], T, 0.0, 0.0,
'c'))
iv_rho_rho_zero.append(
implied_volatility(price_rho_zero, f0, strikes[i], T, 0.0, 0.0, 'c'))
plt.plot(strikes,
iv_vol_rho,
label="rho=%s" % rho,
marker=".",
linestyle="--",
color="black")
plt.plot(strikes,
iv_rho_rho_zero,
label="rho=0.0",
marker="+",
linestyle="--",
color="black")
# Upper and lower bound for cos integral
a = -10.0
b = 10.0
# maturities
T = [0.2, 0.4, 0.6, 1.0]
markers = ['.', '+', '*', '^']
no_maturities = len(T)
for i in range(0, no_maturities):
cf_merton = partial(JumpDiffusionCharesticFunction.get_merton_cf, t=T[i], x=x0, sigma=sigma, jumpmean=jumpmean,
jumpstd=jumpstd, lambda_t=lambda_t)
# check martingale
aux = cf_merton(np.asfortranarray(3.0))
cos_price_merton = COSRepresentation.get_european_option_price(TypeEuropeanOption.CALL, a, b, 256, k_s, cf_merton)
iv_smile_merton = []
for k in range(0, no_strikes):
iv_smile_merton.append(implied_volatility(cos_price_merton[k], f0, f0, T[i], 0.0, 0.0, 'c'))
plt.plot(k_s, iv_smile_merton, label='T=%s' % T[i], linestyle='--', color='black', marker=markers[i])
# plt.ylim([0.0, 1.0])
plt.xlabel('K')
plt.legend()
plt.show()
iv_smile = []
rnd_generator.set_seed(seed)
no_time_steps = np.maximum(int(T[i] * 365.0), 5)
map_output = RBergomi_Engine.get_path_multi_step(
0.0, T[i], parameters, f0, sigma_0, no_paths, no_time_steps,
Types.TYPE_STANDARD_NORMAL_SAMPLING.ANTITHETIC, rnd_generator)
for k_i in strikes:
options.append(
EuropeanOption(k_i, 1.0, TypeSellBuy.BUY, TypeEuropeanOption.CALL,
f0, T[i]))
mc_option_price = options[-1].get_price_control_variate(
map_output[Types.RBERGOMI_OUTPUT.PATHS][:, -1],
map_output[Types.RBERGOMI_OUTPUT.INTEGRAL_VARIANCE_PATHS])
iv_smile.append(
implied_volatility(mc_option_price[0], f0, k_i, T[i], 0.0, 0.0,
'c'))
plt.plot(strikes,
iv_smile,
label=labels[i],
color='black',
marker=markers[i],
linestyle="--")
path_to_keep = os.path.join(
"D://GitHubRepository//Python//Graficos//Chapter8",
"rbergomi_smile_%s" % i + ".png")
plt.xlabel('K', fontsize=14)
plt.legend(fontsize=14)
plt.ylim([0.0, 0.9])
plt.savefig(path_to_keep)
import py_vollib.black_scholes_merton.implied_volatility as BSvol import py_vollib.black_scholes_merton.greeks.analytical as BSgreeks t = 10 / 365 price = 0.56 S = 233.2 K = 235 flag = 'c' r = .02 q = .0224 iv = BSvol.implied_volatility(price, S, K, t, r, q, flag) td = BSgreeks.theta(flag, S, K, t, r, iv, q) print(round(iv, 3)) print(round(td, 3))
option_vix_price = []
implied_vol_vix = []
for i in range(0, no_strikes):
rnd_generator.set_seed(seed)
map_output = SABR_Engine.get_path_multi_step(
0.0, T, parameters, f0, no_paths, no_time_steps,
Types.TYPE_STANDARD_NORMAL_SAMPLING.ANTITHETIC, rnd_generator)
index_t_i = np.searchsorted(map_output[Types.SABR_OUTPUT.TIMES], T)
price = np.mean(
np.maximum(
beta_vix * map_output[Types.SABR_OUTPUT.SIGMA_PATHS][:, index_t_i]
- strikes[i], 0.0))
option_vix_price.append(price)
implied_vol_vix.append(
round(
implied_volatility(option_vix_price[-1], vix_t0, strikes[i], T,
0.0, 0.0, 'c'), 5))
plt.plot(strikes,
implied_vol_vix,
linestyle='--',
label='Implied Vol VIX',
color='black',
marker='.')
plt.ylim([0.5, 1.0])
plt.xlabel('K')
plt.legend()
plt.show()
axis=0)
mean_asset = np.mean(map_output[Types.BERGOMI2F_OUTPUT.PATHS], axis=0)
option_vix_price = []
implied_vol_vix = []
analytic_value = []
for i in range(0, no_strikes):
index_t_i = np.searchsorted(map_output[Types.BERGOMI2F_OUTPUT.TIMES], T)
price = np.mean(
np.maximum(
np.sqrt(map_output[Types.BERGOMI2F_OUTPUT.SPOT_VARIANCE_PATHS]
[:, index_t_i]) - strikes[i], 0.0))
# analytic_value.append(0.5 * (epsilon * sigma_0 / (k * vix_t0 * vix_t0)) * beta_vix)
option_vix_price.append(price)
implied_vol_vix.append(
implied_volatility(price, vix_t0, strikes[i], T, 0.0, 0.0, 'c'))
plt.plot(strikes,
implied_vol_vix,
linestyle='--',
label='ATM IV VIX',
color='black',
marker='.')
plt.title('theta = %s' % theta)
plt.xlabel('K')
plt.legend()
plt.show()
rnd_generator,
)
t_i_vix = T_VIX[i] + delta_vix
index_t_i = np.searchsorted(map_output[Types.RBERGOMI_OUTPUT.TIMES],
T_VIX[i])
vix_t = ExpansionTools.get_vix_rbergomi_t(
T_VIX[i], t_i_vix, delta_vix, nu, h,
map_output[Types.RBERGOMI_OUTPUT.VARIANCE_SPOT_PATHS][:, index_t_i],
v0, 200)
price = np.mean(np.maximum(vix_t - vix_t0, 0.0))
option_vix_price.append(price)
implied_vol_vix.append(
implied_volatility(option_vix_price[-1], vix_t0, vix_t0, T_VIX[i], 0.0,
0.0, 'c'))
analytic_value = nu * np.sqrt(2.0 * h) * v0 * np.power(delta_vix, h - 0.5) / (
(h + 0.5) * vix_t0 * vix_t0)
plt.plot(T_VIX,
implied_vol_vix,
linestyle='--',
label='ATM IV VIX',
color='black',
marker='.')
plt.xlabel('T')
plt.legend()
plt.show()
vix_t_0_aux = ExpansionTools.get_vix_rbergomi_t(0.000001, delta_vix + 0.000001, delta_vix, nu, h,
np.asfortranarray(v0),
v0, 200)
no_strikes = 30
strikes = np.linspace(0.95, 1.05, no_strikes) * vix_t0
map_output = RBergomi_Engine.get_path_multi_step(0.0, T, parameters, f0, sigma_0, no_paths, no_time_steps,
Types.TYPE_STANDARD_NORMAL_SAMPLING.ANTITHETIC, rnd_generator)
for i in range(0, no_strikes):
t_i_vix = T + delta_vix
index_t_i = np.searchsorted(map_output[Types.RBERGOMI_OUTPUT.TIMES], T)
vix_t = ExpansionTools.get_vix_rbergomi_t(T, t_i_vix, delta_vix, nu, h,
map_output[Types.RBERGOMI_OUTPUT.VARIANCE_SPOT_PATHS][:, index_t_i],
v0, 200)
price = np.mean(np.maximum(vix_t -
strikes[i], 0.0))
option_vix_price.append(price)
implied_vol_vix.append(implied_volatility(option_vix_price[-1], vix_t0, strikes[i], T, 0.0, 0.0, 'c'))
analytic_value = nu * np.sqrt(2.0 * h) * v0 * np.power(delta_vix, h - 0.5) / ((h + 0.5) * vix_t0 * vix_t0)
plt.plot(strikes, implied_vol_vix, linestyle='--', label='Implied Vol VIX', color='black', marker='.')
plt.xlabel('K')
plt.legend()
plt.show()
no_T_s = len(T_s)
options = []
for t_i in T_s:
options.append(EuropeanOption(f0, 1.0, TypeSellBuy.BUY, TypeEuropeanOption.CALL, f0, t_i))
for i in range(0, no_T_s):
rnd_generator.set_seed(seed)
map_output = RBergomi_Engine.get_path_multi_step(0.0, T_s[i], parameters, f0, v0, no_paths,
no_time_steps, Types.TYPE_STANDARD_NORMAL_SAMPLING.ANTITHETIC,
rnd_generator)
options = []
for k_i in k_s:
options.append(EuropeanOption(k_i, 1.0, TypeSellBuy.BUY, TypeEuropeanOption.CALL, f0, T_s[i]))
implied_vol = []
for j in range(0, no_k_s):
mc_option_price = options[j].get_price_control_variate(map_output[Types.RBERGOMI_OUTPUT.PATHS][:, -1],
map_output[Types.RBERGOMI_OUTPUT.INTEGRAL_VARIANCE_PATHS])
implied_vol.append(implied_volatility(mc_option_price[0], f0, k_s[j], T_s[i], 0.0, 0.0, 'c'))
plt.plot(k_s, implied_vol, label="T=%s" % round(T_s[i], 5), linestyle='--', marker=markers[i], color='black')
plt.xlabel('K')
plt.ylabel('iv')
plt.legend()
plt.show()
# option information
# options
strikes = np.linspace(70.0, 130.0, 30)
no_strikes = len(strikes)
f0 = 100
T = 0.1
notional = 1.0
options = []
for k_i in strikes:
options.append(EuropeanOption(k_i, notional, TypeSellBuy.BUY, TypeEuropeanOption.CALL, f0, T))
map_output = SABR_Engine.get_path_multi_step(0.0, T, parameters, f0, no_paths, no_time_steps,
Types.TYPE_STANDARD_NORMAL_SAMPLING.REGULAR_WAY, rnd_generator)
iv_vol = []
for i in range(0, no_strikes):
rnd_generator.set_seed(seed)
mc_option_price = options[i].get_price_control_variate(map_output[Types.SABR_OUTPUT.PATHS][:, -1],
map_output[Types.SABR_OUTPUT.INTEGRAL_VARIANCE_PATHS])
iv_vol.append(implied_volatility(mc_option_price[0], f0, strikes[i], T, 0.0, 0.0, 'c'))
plt.plot(strikes, iv_vol, label="rho=%s" % rho, marker=".", linestyle="--", color="black")
plt.xlabel("K")
plt.legend()
plt.show()
Types.TYPE_STANDARD_NORMAL_SAMPLING.ANTITHETIC, rnd_generator)
option_price_mc = options[i].get_price_control_variate(
map_output[Types.HESTON_OUTPUT.PATHS][:, -1],
map_output[Types.HESTON_OUTPUT.INTEGRAL_VARIANCE_PATHS])
option_price_right_mc = options_shift_right[i].get_price_control_variate(
map_output[Types.HESTON_OUTPUT.PATHS][:, -1],
map_output[Types.HESTON_OUTPUT.INTEGRAL_VARIANCE_PATHS])
option_price_left_mc = options_shift_left[i].get_price_control_variate(
map_output[Types.HESTON_OUTPUT.PATHS][:, -1],
map_output[Types.HESTON_OUTPUT.INTEGRAL_VARIANCE_PATHS])
implied_vol_atm.append(
implied_volatility(option_price_mc[0], f0, f0, dt[i], 0.0, 0.0, 'c'))
implied_vol_atm_shift_right.append(
implied_volatility(option_price_right_mc[0], f0,
f0 * (1.0 + shift_spot), dt[i], 0.0, 0.0, 'c'))
implied_vol_atm_shift_left.append(
implied_volatility(option_price_left_mc[0], f0,
f0 * (1.0 - shift_spot), dt[i], 0.0, 0.0, 'c'))
smile_atm.append(
(implied_vol_atm_shift_right[i] - 2.0 * implied_vol_atm[i] +
implied_vol_atm_shift_left[i]) / (f0 * f0 * shift_spot * shift_spot))
asymptotic_limit = (1.0 - rho * rho * 2.5) * epsilon * epsilon / (
12.0 * np.power(sigma_0, 3.0))
plt.plot(dt, smile_atm, label='smile atm heston', color='black')
plt.plot(dt,
no_time_steps = 100
no_paths = 1000000
else:
no_time_steps = 100
no_paths = 1000000
rnd_generator.set_seed(seed)
map_output = RBergomi_Engine.get_path_multi_step(0.0, dt[i], parameters, f0, sigma_0, no_paths,
no_time_steps, Types.TYPE_STANDARD_NORMAL_SAMPLING.REGULAR_WAY,
rnd_generator)
# mc_option_price = options[i].get_price(map_output[Types.RBERGOMI_OUTPUT.PATHS][:, -1])
mc_option_price = options[i].get_price_control_variate(map_output[Types.RBERGOMI_OUTPUT.PATHS][:, -1],
map_output[Types.RBERGOMI_OUTPUT.INTEGRAL_VARIANCE_PATHS])
implied_vol_atm.append(implied_volatility(mc_option_price[0], f0, f0, dt[i], 0.0, 0.0, 'c'))
vol_swap_mc.append(np.mean(np.sqrt(np.sum(map_output[Types.RBERGOMI_OUTPUT.INTEGRAL_VARIANCE_PATHS], 1) / dt[i])))
implied_vol_approx.append(
ExpansionTools.get_iv_atm_rbergomi_approximation(parameters, vol_swap_mc[i], sigma_0, dt[i], 'var_swap'))
error_mc_vol_swap = np.std(
np.sqrt(np.sum(map_output[Types.RBERGOMI_OUTPUT.INTEGRAL_VARIANCE_PATHS], 1) / dt[i])) / np.sqrt(no_paths)
vol_swap_approx.append(ExpansionTools.get_vol_swap_rbergomi(parameters, sigma_0, dt[i]))
variance_swap.append(ExpansionTools.get_variance_swap_rbergomi(parameters, sigma_0, dt[i]))
variance_swap_mc.append(np.sqrt(np.mean(np.sum(map_output[Types.RBERGOMI_OUTPUT.INTEGRAL_VARIANCE_PATHS], 1) / dt[i])))
output_vol_swap.append(implied_vol_atm[i] - vol_swap_mc[i])
output_variance_swap.append(implied_vol_atm[i] - variance_swap[i])
diff_vol_swap_var_swap.append(variance_swap[i] - vol_swap_mc[i])
# csv parser
headers = ["time", "iv_atm", "iv_atm_approx", "vol_swap_mc", "vol_swap_approx", "variance_swap", "out_variance_swap",
"out_vol_swap"]
map_output[Types.SABR_OUTPUT.PATHS][:, -1],
map_output[Types.SABR_OUTPUT.INTEGRAL_VARIANCE_PATHS])
mc_option_price_shift_right = options_shift_right[i].get_price(
map_output[Types.SABR_OUTPUT.PATHS][:, -1])
mc_option_price_cv_right = options_shift_right[
i].get_price_control_variate(
map_output[Types.SABR_OUTPUT.PATHS][:, -1],
map_output[Types.SABR_OUTPUT.INTEGRAL_VARIANCE_PATHS])
mc_option_price_shift_left = options_shift_left[i].get_price(
map_output[Types.SABR_OUTPUT.PATHS][:, -1])
mc_option_price_cv_left = options_shift_left[i].get_price_control_variate(
map_output[Types.SABR_OUTPUT.PATHS][:, -1],
map_output[Types.SABR_OUTPUT.INTEGRAL_VARIANCE_PATHS])
implied_vol_base = implied_volatility(mc_option_price_cv[0], f0, f0, dt[i],
0.0, 0.0, 'c')
implied_vol_shift_right = implied_volatility(mc_option_price_cv_right[0],
f0, f0 * (1.0 + shift_spot),
dt[i], 0.0, 0.0, 'c')
implied_vol_shift_left = implied_volatility(mc_option_price_cv_left[0], f0,
f0 * (1.0 - shift_spot), dt[i],
0.0, 0.0, 'c')
smile_atm_mc.append(
(implied_vol_shift_right - 2.0 * implied_vol_base +
implied_vol_shift_left) / (f0 * f0 * shift_spot * shift_spot))
def f_law(x, a, b, c):
return a + b * np.power(x, -c)
options.append(
EuropeanOption(k_i, notional, TypeSellBuy.BUY, TypeEuropeanOption.CALL,
f0, T))
iv_vol = []
for i in range(0, no_strikes):
price = options[i].get_analytic_value(
0.0,
theta,
rho,
k,
epsilon,
v0,
0.0,
model_type=Types.ANALYTIC_MODEL.HESTON_MODEL_ATTARI,
compute_greek=False)
iv_vol.append(implied_volatility(price, f0, strikes[i], T, 0.0, 0.0, 'c'))
plt.plot(strikes,
iv_vol,
label="rho=%s" % rho,
marker=".",
linestyle="--",
color="black")
plt.xlabel("K")
plt.legend()
plt.show()
