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()