def plot_y(output_data, meta_data):
fig, ax1 = plt.subplots()
time_grid = output_data["time grid"]
ax1.plot(time_grid,
output_data["y bar approx"],
label="Approximate solution (Method A)",
color='r')
ax1.plot(time_grid,
output_data["y_runge_kutta"],
label="ODE system approx (Method B)",
color='g')
error_y = 3 * output_data["y std mc"] / np.sqrt(
meta_data["number_scrambles"])
upper = output_data["y bar mc"] + error_y
lower = output_data["y bar mc"] - error_y
ax1.plot(time_grid,
output_data["y bar mc"],
label="Monte Carlo Simulation",
color='b')
ax1.fill_between(time_grid,
lower,
upper,
label="3 std conf level",
alpha=0.28)
ax1.set_xlabel("time (years)")
ax1.set_ylabel(r"$\mathbb{E}^A[y(t)]$")
title = "{}Y{}Y Swap, $\mathbb{{E}}^A[y(t)]$ approximation".format(
meta_data["swap_T0"], meta_data["swap_TN"] - meta_data["swap_T0"])
ax1.set_title(title)
ax1.legend()
file_name = r"{}-y_approx_{}Y{}Y_swap_kappa_{}_lambda_{:.3f}_alpha_{:.3f}_beta_{:.3f}".format(
meta_data["file_pre"], meta_data["swap_T0"],
meta_data["swap_TN"] - meta_data["swap_T0"], meta_data["kappa"],
meta_data["lambda value"], meta_data["alpha"], meta_data["beta"])
file_name += "." + outp_file_format
output_file = os.path.join(output_plots_approx_solution, file_name)
file_path = get_nonexistant_path(output_file)
savefig_metadata(file_path, outp_file_format, fig, meta_data)
def adi_bond_report():
output_path = os.path.join(output_data_raw_finite_difference,
date_timestamp)
curve_rate = 0.01
maturity_grid = [30]
kappa_grid = [0.03]
theta = 1 / 2
initial_curve = get_mock_yield_curve_const(rate=curve_rate)
vola_parameters = [(i, curve_rate, j) for i in [0.05, 0.1, 0.2, 0.4]
for j in [0.1, 0.3, 0.5, 0.7, 0.9]]
vola_grid_df = pd.DataFrame(vola_parameters,
columns=["lambda", "alpha", "beta"])
finite_difference_parameter = [(100, 150, 20), (300, 400, 80)]
#finite_difference_parameter = [(100, 150, 20)]
finite_difference_grid_df = pd.DataFrame(
finite_difference_parameter,
columns=["t_grid_size", "x_grid_size", "y_grid_size"])
output_path = get_nonexistant_path(output_path)
vola_grid_df = vola_grid_df.loc[(vola_grid_df["lambda"] == 0.4)
& (vola_grid_df["beta"] == 0.35)]
for maturity in maturity_grid:
for kappa in kappa_grid:
bond = Bond(maturity)
bond_pricer = BondPricer(initial_curve, kappa)
for index, vola_grid_row in vola_grid_df.iterrows():
loca_vola = LinearLocalVolatility.from_const(
maturity, vola_grid_row["lambda"], vola_grid_row["alpha"],
vola_grid_row["beta"])
for index, finite_difference_grid_row in finite_difference_grid_df.iterrows(
):
x_grid_size = finite_difference_grid_row["x_grid_size"]
y_grid_size = finite_difference_grid_row["y_grid_size"]
t_grid_size = finite_difference_grid_row["t_grid_size"]
t_min = 0
t_max = maturity
x_min, x_max = calculate_x_boundaries2(t_max,
loca_vola,
alpha=3)
x_min, x_max = calculate_x_boundaries3(t_max,
kappa,
loca_vola,
alpha=3)
u_min, u_max = calculate_u_boundaries(t_max,
kappa,
loca_vola,
alpha=4)
mesher = Mesher2d()
mesher.create_mesher_2d(t_min, t_max, t_grid_size, x_min,
x_max, x_grid_size, u_min, u_max,
y_grid_size)
adi_runner = AdiRunner(theta, kappa, initial_curve,
loca_vola, mesher)
bond_t0 = pd.DataFrame(
adi_runner.run_adi(bond, bond_pricer))
output_file = os.path.join(output_path,
"bond_price_fd.hdf")
file_path = get_nonexistant_path(output_file)
meta_data = {
"x_grid_size": int(x_grid_size),
"y_grid_size": int(y_grid_size),
"maturity": maturity,
"t_grid_size": int(t_grid_size),
"vola_lambda": vola_grid_row["lambda"],
"vola_alpha": vola_grid_row["alpha"],
"vola_beta": vola_grid_row["beta"],
"curve_rate": curve_rate,
"kappa": kappa
}
meta_data = pd.DataFrame(meta_data, index=[0])
bond_t0.to_hdf(file_path, key="data", complevel=5)
meta_data.to_hdf(file_path, key="metadata", complevel=5)
pd.DataFrame(mesher.xmesh).to_hdf(file_path,
key='xmesh',
complevel=5)
pd.DataFrame(mesher.umesh).to_hdf(file_path,
key='ymesh',
complevel=5)
pd.DataFrame(mesher.xgrid).to_hdf(file_path,
key='xgrid',
complevel=5)
pd.DataFrame(mesher.ugrid).to_hdf(file_path,
key='ygrid',
complevel=5)
def plot_all(all_results, output_path):
for swap, group in all_results.groupby(["expiry", "maturity"]):
plot_implied_vola(group, output_path)
pass
fd_file = os.path.join(output_data_raw, "finite_difference", "swaption",
"2021_01_08")
mc_file = os.path.join(output_data_raw, "monte_carlo", "swaption",
"2021_01_07")
approx_file = os.path.join(output_data_raw, "approximation",
"piterbarg_swaption_approx", "2021_01_11", "result",
'swaption_approximation-2.hdf')
approx_file = os.path.join(output_data_raw, "approximation",
"piterbarg_swaption_approx", "2021_01_10", "result",
'swaption_approximation.hdf')
output_swaption = os.path.join(output_plots_swaption)
all_results = load_swaption_data(approx_file, mc_file, fd_file)
output_path = os.path.join(output_swaption, date_timestamp)
output_path = get_nonexistant_path(output_path)
try:
os.mkdir(output_path)
except:
pass
plot_all(all_results, output_path)
def mc_swaption_report():
output_path = os.path.join(output_data_raw_monte_carlo, date_timestamp)
output_file = os.path.join(output_path, "swaption_price_mc.hdf")
file_path = get_nonexistant_path(output_file)
#random_number_generator_type = "sobol"
random_number_generator_type = "normal"
curve_rate = 0.06
kappa_grid = [0.03]
initial_curve = get_mock_yield_curve_const(rate=curve_rate)
vola_parameters = [(i, curve_rate, j) for i in [0.05, 0.2, 0.4, 0.5] for j in [0.05, 0.1, 0.3, 0.7]]
vola_parameters = [(i, curve_rate, j) for i in [0.4] for j in [0.3]]
vola_grid_df = pd.DataFrame(vola_parameters, columns=["lambda", "alpha", "beta"])
coupon_grid = [0, +0.0025, -0.0025, +0.005, -0.005, +0.01, -0.01, 0.015, -0.015, 0.02, -0.02, 0.025, -0.025]
#vola_grid_df = vola_grid_df.iloc[[10]]
number_paths = np.power(2, 15)
number_time_steps = np.power(2, 11)
swap_ls = [(1, 6), (5, 10), (10, 20), (20, 30), (25, 30)]
swap_ls = [(5, 10), (10, 20), (20, 30)]
swap_ls = [(5, 10)]
#swap_ls = [(1, 11)]
for number_paths in [np.power(2,12), np.power(2, 13), np.power(2, 14), np.power(2, 15), np.power(2, 16), np.power(2, 17)]:
for swap_exp_mat in swap_ls:
print("swap: ", swap_exp_mat)
expiry, maturity = swap_exp_mat
for kappa in kappa_grid:
swap_pricer = SwapPricer(initial_curve, kappa)
swaption_pricer = SwaptionPricer(swap_pricer)
swap = Swap(expiry, maturity, 0.5)
atm_swap_price = swap_pricer.price(swap, 0, 0, 0)
strike_grid = [atm_swap_price+coupon for coupon in coupon_grid]
for index, vola_grid_row in vola_grid_df.iterrows():
loca_vola = LinearLocalVolatility.from_const(maturity, vola_grid_row["lambda"],
vola_grid_row["alpha"], vola_grid_row["beta"])
bond_measure = swap.bond_T0
process_simulator = ProcessSimulatorTerminalMeasure(number_paths, number_time_steps,
expiry / number_time_steps,
random_number_generator_type, bond_measure,
swap_pricer.bond_pricer, nr_processes=6,
n_scrambles=64)
result_obj = process_simulator.simulate_xy(kappa, loca_vola, parallel_simulation=True)
for strike in strike_grid:
swaption = Swaption(expiry, strike, swap)
swaption_value_paths = monte_carlo_pricer_terminal_measure(result_obj, swaption, swaption_pricer)
last_mc_time = result_obj.time_grid[-1]
# swaption_value_paths_cv = apply_control_variate(last_mc_time, result_obj.x[:,-1], result_obj.y[:,-1],
# swaption_value_paths, swap.bond_TN, swap_pricer.bond_pricer, swap_pricer.initial_curve)
swaption_value_paths_cv2 = apply_control_variate_annuity(last_mc_time, result_obj.x[:, -1],
result_obj.y[:, -1], swaption_value_paths,
swap.annuity, swap_pricer.annuity_pricer,
swap_pricer.annuity_pricer.bond_pricer.initial_curve)
swaption_value_mean = swaption_value_paths.mean()
std, swaption_value_error = result_obj.calculate_std_error(swaption_value_paths, result_obj.n_scrambles)
# swaption_value_mean_cv = swaption_value_paths_cv.mean()
# std, swaption_value_error_cv = result_obj.calculate_std_error(swaption_value_paths_cv, result_obj.n_scrambles)
swaption_value_mean_cv = swaption_value_paths_cv2.mean()
std, swaption_value_error_cv = result_obj.calculate_std_error(swaption_value_paths_cv2,
result_obj.n_scrambles)
bond_pricer = swap_pricer.bond_pricer
output_data = {"number_paths": number_paths, "number_time_steps": number_time_steps,
"random_number_generator_type": random_number_generator_type, "expiry": expiry,
"maturity": maturity, "strike": strike, "atm strike": atm_swap_price,
"moneyness": strike-atm_swap_price, "vola_lambda": vola_grid_row["lambda"],
"vola_alpha": vola_grid_row["alpha"], "vola_beta": vola_grid_row["beta"],
"curve_rate": curve_rate, "kappa": kappa, "swaption value": swaption_value_mean,
"swaption value error": swaption_value_error,
"swaption value cv": swaption_value_mean_cv,
"swaption value error cv": swaption_value_error_cv,
"implied_vola": find_implied_black_vola(swaption_value_mean, swaption,
swap_pricer, bond_pricer),
"implied_vola_max": find_implied_black_vola(swaption_value_mean+swaption_value_error,
swaption, swap_pricer, bond_pricer),
"implied_vola_min": find_implied_black_vola(swaption_value_mean-swaption_value_error,
swaption, swap_pricer, bond_pricer),
"implied_vola_cv": find_implied_black_vola(swaption_value_mean_cv, swaption,
swap_pricer, bond_pricer),
"implied_vola_cv_max": find_implied_black_vola(swaption_value_mean_cv + swaption_value_error_cv, swaption,
swap_pricer, bond_pricer),
"implied_vola_cv_min": find_implied_black_vola(swaption_value_mean_cv - swaption_value_error_cv, swaption,
swap_pricer, bond_pricer)}
output_df_new = pd.DataFrame(output_data, index=[0])
try:
ouput_df_old = pd.read_hdf(file_path, key="output_data")
except:
ouput_df_old = pd.DataFrame()
output_df_new = pd.concat([ouput_df_old, output_df_new])
output_df_new.to_hdf(file_path, key="output_data", complevel=9)
def calculate_swaption_prices():
output_path = os.path.join(output_data_raw_approx, date_timestamp,
"result")
output_file = os.path.join(output_path, "swaption_approximation.hdf")
file_path = get_nonexistant_path(output_file)
grid_size = 2**12 + 1
swap_freq = 0.5
curve_rate = 0.06
initial_curve = LiborCurve.from_constant_rate(curve_rate)
kappa_grid = [0.03]
vola_parameters = [(i, curve_rate, j) for i in [0.6, 0.8]
for j in [0.05, 0.2]]
vola_grid_df = pd.DataFrame(vola_parameters,
columns=["lambda", "alpha", "beta"])
vola_grid_df = vola_grid_df.iloc[[0, 3]]
#coupon_grid = [0, +0.0025, -0.0025, +0.005, -0.005, +0.01, -0.01, 0.015, -0.015, 0.02, -0.02, 0.025, -0.025]
XYApproximator = PitergargDiscreteXY
XYApproximator = RungeKuttaApproxXY
swap_ls = [(20, 21)]
coupon_grid = [0, +0.005, -0.005, +0.01, -0.01, 0.015, -0.015]
#vola_grid_df = vola_grid_df.iloc[9:10]
for swap_T0_TN in swap_ls:
print(swap_T0_TN)
T0, TN = swap_T0_TN
for kappa in kappa_grid:
swap_pricer = SwapPricer(initial_curve, kappa)
swap = Swap(T0, TN, 1 / 2)
for index, vola_grid_row in vola_grid_df.iterrows():
sigma_r = LinearLocalVolatility.from_const(
swap.TN, vola_grid_row["lambda"], vola_grid_row["alpha"],
vola_grid_row["beta"])
swap = Swap(T0, TN, swap_freq)
atm_swap_price = swap_pricer.price(swap, 0, 0, 0)
strike_grid = [
atm_swap_price + coupon for coupon in coupon_grid
]
#strike_grid = [0.01, 0.015, 0.02, 0.025, 0.03]
xy_calculator = XYApproximator(grid_size, swap_pricer, sigma_r,
swap)
integration_approx = DiscreteParameterAveraging(
grid_size, swap_pricer, sigma_r, swap, xy_calculator)
lambda_avg, beta_avg = integration_approx.calculate_average_param(
)
for strike in strike_grid:
swaption = Swaption(T0, strike, swap)
swaption_value, black_implied_vola = lognormalimpliedvola(
swaption, swap_pricer, lambda_avg, beta_avg)
output_data = pd.DataFrame({
'expiry': [T0],
"maturity": [TN],
"atm strike":
atm_swap_price,
"swaption_value": [swaption_value],
"kappa": [kappa],
"vola_lambda": [vola_grid_row["lambda"]],
"vola_alpha": [vola_grid_row["alpha"]],
"vola_beta": [vola_grid_row['beta']],
"strike": [strike],
'moneyness': [strike - atm_swap_price],
"curve_rate": [curve_rate],
"implied_black_vola": [black_implied_vola],
'integration_grid': [grid_size],
"xy_approximation": [str(xy_calculator)]
})
try:
all_output_data = pd.read_hdf(file_path, key="data")
except:
all_output_data = pd.DataFrame()
all_output_data = pd.concat([all_output_data, output_data])
all_output_data.to_hdf(file_path, key="data", complevel=9)
def adi_swaption_report():
output_path = os.path.join(output_data_raw_finite_difference, date_timestamp)
curve_rate = 0.06
kappa_grid = [0.03]
theta = 1/2
initial_curve = get_mock_yield_curve_const(rate=curve_rate)
finite_difference_parameter = [(100, 150, 10), (400, 800, 60)]
finite_difference_parameter = [(150, 200, 80)]
#finite_difference_parameter = [(400, 800, 60)]
#finite_difference_parameter = [(800, 1000, 100)]
finite_difference_parameter = [(50, 100, 10), (100, 150, 20), (150, 200, 40), (200, 300, 60), (300, 400, 80)]
finite_difference_parameter = [(400, 600, 100)]
#finite_difference_parameter = [(600, 800, 120)]
#finite_difference_parameter = [(100, 150, 20), (150, 200, 40), (300, 400, 80), (400, 600, 100)]
#finite_difference_parameter = [ (400, 600, 100)]
finite_difference_parameter = [(100, 150, 20), (150, 200, 40), (300, 400, 80), (400, 600, 100)]
#finite_difference_parameter = [ (400, 600, 100)]
finite_difference_parameter = [(300, 400, 80)]
#finite_difference_parameter = [(150, 200, 40)]
finite_difference_grid_df = pd.DataFrame(finite_difference_parameter, columns=["t_grid_size", "x_grid_size", "y_grid_size"])
output_path = get_nonexistant_path(output_path)
vola_parameters = [(i, curve_rate, j) for i in [0.6, 0.8] for j in [0.05, 0.2]]
vola_grid_df = pd.DataFrame(vola_parameters, columns=["lambda", "alpha", "beta"])
#coupon_grid = [0, +0.0025, -0.0025, +0.005, -0.005, +0.01, -0.01, 0.015, -0.015, 0.02, -0.02, 0.025, -0.025]
#swap_ls = [(1, 6), (5, 10), (10, 20), (20, 30), (25, 30)]
#swap_ls = [(1,6), (5, 10), (10,20)]
swap_ls = [(20, 21)]
coupon_grid = [0, +0.005, -0.005, +0.01, -0.01, 0.015, -0.015]
#coupon_grid = [0]
#coupon_grid = [0]
#swap_ls = [(5, 10)]
#finite_difference_grid_df = finite_difference_grid_df[:-1]
vola_grid_df = vola_grid_df.iloc[[0, 3]]
for swap_exp_mat in swap_ls:
expiry, maturity = swap_exp_mat
for kappa in kappa_grid:
swap_pricer = SwapPricer(initial_curve, kappa)
swaption_pricer = SwaptionPricer(swap_pricer)
swap = Swap(expiry, maturity, 0.5)
atm_swap_price = swap_pricer.price(swap, 0, 0, 0)
strike_grid = [atm_swap_price+coupon for coupon in coupon_grid]
#strike_grid = [0.01, 0.015, 0.02, 0.025, 0.03]
for strike in strike_grid:
swaption = Swaption(expiry, strike, swap)
for index, vola_grid_row in vola_grid_df.iterrows():
loca_vola = LinearLocalVolatility.from_const(maturity, vola_grid_row["lambda"], vola_grid_row["alpha"], vola_grid_row["beta"])
for index, finite_difference_grid_row in finite_difference_grid_df.iterrows():
x_grid_size = finite_difference_grid_row["x_grid_size"]
y_grid_size = finite_difference_grid_row["y_grid_size"]
t_grid_size = finite_difference_grid_row["t_grid_size"]
t_min = 0
t_max = expiry
x_min, x_max = calculate_x_boundaries2(t_max, loca_vola, alpha=3)
x_min, x_max = calculate_x_boundaries3(expiry, kappa, loca_vola, alpha=4)
y_min, y_max = calculate_u_boundaries(t_max, kappa, loca_vola, alpha=4)
mesher = Mesher2d()
mesher.create_mesher_2d(t_min, t_max, t_grid_size, x_min, x_max, x_grid_size, y_min, y_max,
y_grid_size)
adi_runner = AdiRunner(theta, kappa, initial_curve, loca_vola, mesher)
swaption_t0 = pd.DataFrame(adi_runner.run_adi(swaption, swaption_pricer))
output_file = os.path.join(output_path, "swaption_price_fd.hdf")
file_path = get_nonexistant_path(output_file)
swaption_t0_x0_y0 = extract_x0_result(swaption_t0.values, mesher.xgrid, mesher.ugrid)
implied_black_vola = find_implied_black_vola(swaption_t0_x0_y0, swaption, swap_pricer, swap_pricer.bond_pricer)
meta_data = {"expiry": expiry, "maturity": maturity, "strike": strike,
"atm strike": atm_swap_price, "moneyness": strike - atm_swap_price,
"x_grid_size": int(x_grid_size), "y_grid_size": int(y_grid_size),
"t_grid_size": int(t_grid_size),
"vola_lambda": vola_grid_row["lambda"], "vola_alpha": vola_grid_row["alpha"],
"vola_beta": vola_grid_row["beta"], "curve_rate": curve_rate, "kappa": kappa,
"swaption_value": swaption_t0_x0_y0, "implied_black_vola": implied_black_vola}
meta_data = pd.DataFrame(meta_data, index=[0])
swaption_t0.to_hdf(file_path, key="data", complevel=5)
meta_data.to_hdf(file_path, key="metadata", complevel=5)
print(meta_data)
pd.DataFrame(mesher.xmesh).to_hdf(file_path, key='xmesh', complevel=5)
pd.DataFrame(mesher.umesh).to_hdf(file_path, key='ymesh', complevel=5)
pd.DataFrame(mesher.xgrid).to_hdf(file_path, key='xgrid', complevel=5)
pd.DataFrame(mesher.ugrid).to_hdf(file_path, key='ygrid', complevel=5)