def get_lsmc_values(setups, nsims=5000):
values = []
errors = []
for num_setting in setups:
log_debug(num_setting, 'setting')
######### load setting
ret = get_setting(num_setting)
val_date = ret['val_date']
dates = ret['dates']
cons = ret['cons']
model_params = ret['model_params']
fwd_curve = ret['fwd_curve']
Fc_mean = ret['Fc_mean']
delta_F = ret['delta_F']
Te = calcTe(val_date, dates)
Te_ext = np.append(Te, Te[-1] + 1. / 365.)
nTe = Te.size
fwd_array = fwd_curve.values
Te = calcTe(val_date, dates)
fwd_array = fwd_curve.values
########## run instrinsic
results, TP = run_one_valuation_intrinsic(Te, fwd_array, cons)
cashflows = results['cashflows'].spot + results['cashflows'].opex
mean_cf = cashflows.mean(axis=1)
intr_value = mean_cf.sum()
########## run lsmc
stoch_value, stoch_value_error = run_valuation_stochastic(val_date,
dates,
fwd_curve,
cons,
model_params,
nsims=nsims)
time_value = stoch_value - intr_value
log_debug("stoch value = {:.4g} +- {:.4g}".format(
stoch_value, stoch_value_error))
log_debug("time value = {:.4g} +- {:.4g}".format(
time_value, stoch_value_error))
values.append(time_value)
errors.append(stoch_value_error)
return np.array(values), np.array(errors)
def get_lsmc_values(setups, nsims=5000):
values = []
errors = []
for num_setting in setups:
log_debug(num_setting, "setting")
######### load setting
ret = get_setting(num_setting)
val_date = ret["val_date"]
dates = ret["dates"]
cons = ret["cons"]
model_params = ret["model_params"]
fwd_curve = ret["fwd_curve"]
Fc_mean = ret["Fc_mean"]
delta_F = ret["delta_F"]
Te = calcTe(val_date, dates)
Te_ext = np.append(Te, Te[-1] + 1.0 / 365.0)
nTe = Te.size
fwd_array = fwd_curve.values
Te = calcTe(val_date, dates)
fwd_array = fwd_curve.values
########## run instrinsic
results, TP = run_one_valuation_intrinsic(Te, fwd_array, cons)
cashflows = results["cashflows"].spot + results["cashflows"].opex
mean_cf = cashflows.mean(axis=1)
intr_value = mean_cf.sum()
########## run lsmc
stoch_value, stoch_value_error = run_valuation_stochastic(
val_date, dates, fwd_curve, cons, model_params, nsims=nsims
)
time_value = stoch_value - intr_value
log_debug("stoch value = {:.4g} +- {:.4g}".format(stoch_value, stoch_value_error))
log_debug("time value = {:.4g} +- {:.4g}".format(time_value, stoch_value_error))
values.append(time_value)
errors.append(stoch_value_error)
return np.array(values), np.array(errors)
def run_valuation_stochastic(val_date, dates, fwd_curve, cons, model_params, nsims=5000):
"""
Calculate stochastic storage with simple constraints
Parameters
----------
Te : maturities
fwd_array:
cons : tuple
(max_inv, min_inv, start_inv, end_inv, inj_cost, rel_cost, rmin, rmax)
Returns
-------
"""
max_inv = cons.max_inv
min_inv = cons.min_inv
start_inv = cons.start_inv
end_inv = cons.end_inv
inj_cost = cons.inj_cost
rel_cost = cons.rel_cost
rmin = cons.rmin
rmax = cons.rmax
sigma_1 = model_params.sigma_1
sigma_2 = model_params.sigma_2
alpha_1 = model_params.alpha_1
alpha_2 = model_params.alpha_2
rho = model_params.rho
alphas = [alpha_1, alpha_2]
sigmas = [sigma_1, sigma_2]
Te = calcTe(val_date, dates)
fc = FlowConstraint(rmin, rmax)
flow_constraints = FlowConstraints(Te[0], fc)
inv_constraints = InventoryConstraints(Te, start_inv, end_inv, max_inv, min_inv, [flow_constraints])
state_object = StateObject(inv_constraints, num_levels=None)
ls_solver_params = AttrDict(max_basis_order=4, solver="RegularisedLeastSquaresSolver")
product = LeastSquaresMonteCarloEngine(
state_object, StorageCashflows(Te, injection_cost=inj_cost, withdrawal_cost=rel_cost), ls_solver_params
)
seed = 123
simulator = MultiFactorSimulator(alphas, sigmas, fwd_curve, rho, val_date, seed=seed)
sims_bwd = simulator.simulate_spot(dates, nsims).values
factors_bwd = simulator.stoch_factors
sims_fwd = simulator.simulate_spot(dates, nsims).values
factors_fwd = simulator.stoch_factors
results = product.calc_extrinsic(sims_bwd, sims_fwd, factors_bwd, factors_fwd)
cashflows = (results["cashflows"].spot + results["cashflows"].opex).sum(axis=0)
value = cashflows.mean()
value_std = cashflows.std()
value_error = value_std / np.sqrt(nsims)
return value, value_error
def get_formula_values(cut_off_params, setups):
wmin_steps = cut_off_params["wmin_steps"]
k_thr = cut_off_params["k_thr"]
correction_weight = cut_off_params["correction_weight"]
values = []
for num_setting in setups:
start_time0 = log_function_enter("setting {}".format(num_setting))
ret = get_setting(num_setting)
val_date = ret["val_date"]
dates = ret["dates"]
cons = ret["cons"]
model_params = ret["model_params"]
fwd_curve = ret["fwd_curve"]
Fc_mean = ret["Fc_mean"]
delta_F = ret["delta_F"]
Te = calcTe(val_date, dates)
Te_ext = np.append(Te, Te[-1] + 1.0 / 365.0)
nTe = Te.size
fwd_array = fwd_curve.values
# estimate mean forward curve and gradient upper bound
F0_mean = fwd_array.mean()
dt = 1.0 / 365.0
dFdt = np.gradient(fwd_array, dt)
F_grad_max = abs(dFdt).max()
results, TP = run_one_valuation_intrinsic(Te, fwd_array, cons)
mean_actions = results.actions.mean(axis=1)
levels = np.empty(nTe + 1, dtype=float)
levels[0] = cons.start_inv
levels[1:] = cons.start_inv + np.cumsum(mean_actions)
minor_sticks = []
for t in range(nTe)[1:]:
if mean_actions[t] != mean_actions[t - 1]:
minor_sticks.append(Te[t])
triggers = calculate_trigger_prices2(TP["dVdq"], Te, fwd_array, mean_actions, cons)
#############################################################
if Te_ext[0] > 0:
Num_0_Ta = Te_ext[0] * 365.0
tenors_0_Ta = np.linspace(0.0, Te_ext[0], Num_0_Ta + 1)
tenors_0_Tb = np.append(tenors_0_Ta, Te_ext[1:])
else:
tenors_0_Tb = Te_ext
integration_dt = np.diff(tenors_0_Tb)
triggers_matrix = np.hstack(
(
triggers.trigger_prices_upper.reshape(-1, 1),
triggers.trigger_prices_lower.reshape(-1, 1),
fwd_array.reshape(-1, 1),
)
)
trigger_interpolator = Interpolate1D(Te, triggers_matrix, kind="linear")
num_time_steps = tenors_0_Tb.size
rmax = cons.rmax
rmin = cons.rmin
rmax *= 365
rmin *= 365
time_value1 = 0
time_value_evolution = np.zeros(num_time_steps)
I1_evolution1 = np.zeros(num_time_steps - 1)
I2_evolution1 = np.zeros(num_time_steps - 1)
mu_evolution1 = np.zeros(num_time_steps - 1)
start_time = log_function_enter("integration time loop")
for n in range(num_time_steps - 1):
# log_debug('time step {} of {}'.format(n, num_time_steps - 1), std_out=False)
t = tenors_0_Tb[n]
tm = max(t, Te[0])
Tb = tenors_0_Tb[-1]
dt = 1.0 / 365.0
num_steps = int(np.round((Tb - tm) / dt))
num_steps *= 5.0
tenors = np.linspace(tm, Tb, num_steps + 1)
# log_debug(t*365., 't*365')
C_all = trigger_interpolator.evaluate(tenors).reshape(-1, 3).T
C_u = C_all[0]
C_d = C_all[1]
F0 = C_all[2]
params = dict()
params["n"] = n
params["t"] = t
params["tenors"] = tenors
params["model_params"] = model_params
params["C_u"] = C_u
params["C_d"] = C_d
params["F0"] = F0
params["rmax"] = rmax
params["rmin"] = rmin
params["F0_mean"] = F0_mean
params["F_grad_max"] = F_grad_max
add_params = dict()
add_params["wmin_steps"] = wmin_steps
add_params["k_thr"] = k_thr
add_params["correction_weight"] = correction_weight
mu_1, I1_1, I2_1 = calculate_mu_bar(params, add_params)
time_value1 += mu_1 * integration_dt[n]
time_value_evolution[n + 1] = time_value1
# log_debug(mu_1, 'mu_1')
# log_debug(I1_1, 'I1_1')
# log_debug(I2_1, 'I2_1')
# log_debug(time_value1, 'time value 1')
I1_evolution1[n] = I1_1
I2_evolution1[n] = I2_1
mu_evolution1[n] = mu_1
log_function_exit("integration time loop", start_time=start_time)
log_debug(time_value1, "final time_value")
# print "approximated time value1 = {:.4g}".format(time_value1)
values.append(time_value1)
log_function_exit("setting {}".format(num_setting), start_time=start_time0)
return np.array(values)
def test_formula(nsims=None):
# val_date, dates, cons, model_params, fwd_curve, Fc, delta_F = setting_1()
# val_date, dates, cons, model_params, fwd_curve, Fc, delta_F = setting_2()
val_date, dates, cons, model_params, fwd_curve, Fc, delta_F = setting_3()
Te = calcTe(val_date, dates)
Te_ext = np.append(Te, Te[-1] + 1.0 / 365.0)
nTe = Te.size
fwd_array = fwd_curve.values
# estimate mean forward curve and gradient upper bound
F0_mean = fwd_array.mean()
dt = 1.0 / 365.0
dFdt = np.gradient(fwd_array, dt)
F_grad_rms = rms(dFdt)
F_grad_max = abs(dFdt).max()
results, TP = run_one_valuation_intrinsic(Te, fwd_array, cons)
cashflows = results["cashflows"].spot + results["cashflows"].opex
mean_cf = cashflows.mean(axis=1)
value = mean_cf.sum()
mean_actions = results.actions.mean(axis=1)
print "intrinsic value = {}".format(value)
levels = np.empty(nTe + 1, dtype=float)
levels[0] = cons.start_inv
levels[1:] = cons.start_inv + np.cumsum(mean_actions)
minor_sticks = []
for t in range(nTe)[1:]:
if mean_actions[t] != mean_actions[t - 1]:
minor_sticks.append(Te[t])
triggers = calculate_trigger_prices2(TP["dVdq"], Te, fwd_array, mean_actions, cons)
# triggers = calculate_trigger_prices(TP['dVdq'], Te, fwd_array, mean_actions, cons)
log_debug(Te, "Te")
log_debug(Te * 365.0, "Te*365")
log_debug(fwd_array, "fwd_array")
log_debug(triggers.trigger_prices_upper, "trigger_prices_upper")
log_debug(triggers.trigger_prices_lower, "trigger_prices_lower")
log_debug(triggers.tt_up * 365.0, "tt_up*365")
log_debug(triggers.tt_down * 365.0, "tt_down*365")
log_debug(triggers.fdot_up, "fdot_up")
log_debug(triggers.fdot_down, "fdot_down")
if nsims is not None and nsims > 0:
stoch_value, stoch_value_error = run_valuation_stochastic(
val_date, dates, fwd_curve, cons, model_params, nsims=nsims
)
print "stoch value = {:.4g} +- {:.4g}".format(stoch_value, stoch_value_error)
print "time value = {:.4g} +- {:.4g}".format(stoch_value - value, stoch_value_error)
plt.close("all")
plt.figure()
plt.plot(Te, fwd_array, "o-", linewidth=1, markersize=2)
plt.plot(Te_ext, levels)
plt.plot(Te, triggers.trigger_prices, "o-", linewidth=1, markersize=2)
plt.plot(Te, triggers.trigger_prices_upper, "--", linewidth=1)
plt.plot(Te, triggers.trigger_prices_lower, "--", linewidth=1)
ax = plt.gca()
# start, end = ax.get_xlim()
ax.xaxis.set_ticks(minor_sticks, minor=True)
plt.grid(True)
ax.xaxis.grid(True, which="minor")
# plt.show()
# return
#############################################################
if Te_ext[0] > 0:
Num_0_Ta = Te_ext[0] * 365.0
tenors_0_Ta = np.linspace(0.0, Te_ext[0], Num_0_Ta + 1)
tenors_0_Tb = np.append(tenors_0_Ta, Te_ext[1:])
else:
tenors_0_Tb = Te_ext
integration_dt = np.diff(tenors_0_Tb)
log_debug(Te_ext * 365.0, "tenors_Ta_Tb*365")
log_debug(tenors_0_Tb * 365.0, "tenors_0_Tb*365")
from mkl.interpolation import Interpolate1D
triggers_matrix = np.hstack(
(
triggers.trigger_prices_upper.reshape(-1, 1),
triggers.trigger_prices_lower.reshape(-1, 1),
fwd_array.reshape(-1, 1),
)
)
trigger_interpolator = Interpolate1D(Te, triggers_matrix, kind="linear")
num_time_steps = tenors_0_Tb.size
rmax = cons.rmax
rmin = cons.rmin
rmax *= 365
rmin *= 365
time_value1 = 0
time_value2 = 0
time_value3 = 0
time_value_evolution = np.zeros(num_time_steps)
I1_evolution1 = np.zeros(num_time_steps - 1)
I2_evolution1 = np.zeros(num_time_steps - 1)
mu_evolution1 = np.zeros(num_time_steps - 1)
I1_evolution2 = np.zeros(num_time_steps - 1)
I2_evolution2 = np.zeros(num_time_steps - 1)
mu_evolution2 = np.zeros(num_time_steps - 1)
for n in range(num_time_steps - 1):
log_function_enter("time loop")
log_debug("time step {} of {}".format(n, num_time_steps - 1), std_out=False)
t = tenors_0_Tb[n]
tm = max(t, Te[0])
Tb = tenors_0_Tb[-1]
dt = 1.0 / 365.0
num_steps = int(np.round((Tb - tm) / dt))
num_steps *= 5.0
tenors = np.linspace(tm, Tb, num_steps + 1)
log_debug(t * 365.0, "t*365")
C_all = trigger_interpolator.evaluate(tenors).reshape(-1, 3).T
C_u = C_all[0]
C_d = C_all[1]
F0 = C_all[2]
params = dict()
params["n"] = n
params["t"] = t
params["tenors"] = tenors
params["model_params"] = model_params
params["C_u"] = C_u
params["C_d"] = C_d
params["F0"] = F0
params["rmax"] = rmax
params["rmin"] = rmin
params["F0_mean"] = F0_mean
params["F_grad_max"] = F_grad_max
add_params = dict()
add_params["wmin_steps"] = 10.0
add_params["k_thr"] = 0.7
add_params["correction_weight"] = 0.5
mu_1, I1_1, I2_1 = calculate_mu_bar(params, add_params)
mu_2, I1_2, I2_2 = calculate_mu_bar_2(t, model_params, rmax, rmin, triggers)
time_value1 += mu_1 * integration_dt[n]
time_value2 += mu_2 * integration_dt[n]
time_value_evolution[n + 1] = time_value1
log_debug(mu_1, "mu_1")
log_debug(I1_1, "I1_1")
log_debug(I2_1, "I2_1")
log_debug(time_value1, "time value 1")
I1_evolution1[n] = I1_1
I2_evolution1[n] = I2_1
mu_evolution1[n] = mu_1
I1_evolution2[n] = I1_2
I2_evolution2[n] = I2_2
mu_evolution2[n] = mu_2
log_function_exit("time loop")
log_debug(time_value1, "final time_value")
print "approximated time value1 = {:.4g}".format(time_value1)
print "approximated time value2 = {:.4g}".format(time_value2)
# plt.figure()
# plt.plot(tenors_0_Tb, time_value_evolution)
# plt.title('time value')
# plt.grid(True)
plt.figure()
plt.plot(tenors_0_Tb[:-1], mu_evolution1, "--r", label="mu1")
plt.plot(tenors_0_Tb[:-1], I1_evolution1, "r", label="I1_evolution_1")
plt.plot(tenors_0_Tb[:-1], I2_evolution1, "r", label="I2_evolution_1")
plt.plot(tenors_0_Tb[:-1], mu_evolution2, "--g", label="mu2")
plt.plot(tenors_0_Tb[:-1], I1_evolution2, "g", linewidth=2, label="I1_evolution_2")
plt.plot(tenors_0_Tb[:-1], I2_evolution2, "g", label="I2_evolution_2")
plt.legend(loc="best")
plt.grid(True)
plt.show()
def get_formula_values(cut_off_params, setups):
wmin_steps = cut_off_params['wmin_steps']
k_thr = cut_off_params['k_thr']
correction_weight = cut_off_params['correction_weight']
values = []
for num_setting in setups:
start_time0 = log_function_enter('setting {}'.format(num_setting))
ret = get_setting(num_setting)
val_date = ret['val_date']
dates = ret['dates']
cons = ret['cons']
model_params = ret['model_params']
fwd_curve = ret['fwd_curve']
Fc_mean = ret['Fc_mean']
delta_F = ret['delta_F']
Te = calcTe(val_date, dates)
Te_ext = np.append(Te, Te[-1] + 1. / 365.)
nTe = Te.size
fwd_array = fwd_curve.values
# estimate mean forward curve and gradient upper bound
F0_mean = fwd_array.mean()
dt = 1. / 365.
dFdt = np.gradient(fwd_array, dt)
F_grad_max = abs(dFdt).max()
results, TP = run_one_valuation_intrinsic(Te, fwd_array, cons)
mean_actions = results.actions.mean(axis=1)
levels = np.empty(nTe + 1, dtype=float)
levels[0] = cons.start_inv
levels[1:] = cons.start_inv + np.cumsum(mean_actions)
minor_sticks = []
for t in range(nTe)[1:]:
if mean_actions[t] != mean_actions[t - 1]:
minor_sticks.append(Te[t])
triggers = calculate_trigger_prices2(TP['dVdq'], Te, fwd_array,
mean_actions, cons)
#############################################################
if Te_ext[0] > 0:
Num_0_Ta = Te_ext[0] * 365.
tenors_0_Ta = np.linspace(0., Te_ext[0], Num_0_Ta + 1)
tenors_0_Tb = np.append(tenors_0_Ta, Te_ext[1:])
else:
tenors_0_Tb = Te_ext
integration_dt = np.diff(tenors_0_Tb)
triggers_matrix = np.hstack(
(triggers.trigger_prices_upper.reshape(-1, 1),
triggers.trigger_prices_lower.reshape(-1, 1),
fwd_array.reshape(-1, 1)))
trigger_interpolator = Interpolate1D(Te,
triggers_matrix,
kind='linear')
num_time_steps = tenors_0_Tb.size
rmax = cons.rmax
rmin = cons.rmin
rmax *= 365
rmin *= 365
time_value1 = 0
time_value_evolution = np.zeros(num_time_steps)
I1_evolution1 = np.zeros(num_time_steps - 1)
I2_evolution1 = np.zeros(num_time_steps - 1)
mu_evolution1 = np.zeros(num_time_steps - 1)
start_time = log_function_enter('integration time loop')
for n in range(num_time_steps - 1):
# log_debug('time step {} of {}'.format(n, num_time_steps - 1), std_out=False)
t = tenors_0_Tb[n]
tm = max(t, Te[0])
Tb = tenors_0_Tb[-1]
dt = 1. / 365.
num_steps = int(np.round((Tb - tm) / dt))
num_steps *= 5.
tenors = np.linspace(tm, Tb, num_steps + 1)
# log_debug(t*365., 't*365')
C_all = trigger_interpolator.evaluate(tenors).reshape(-1, 3).T
C_u = C_all[0]
C_d = C_all[1]
F0 = C_all[2]
params = dict()
params['n'] = n
params['t'] = t
params['tenors'] = tenors
params['model_params'] = model_params
params['C_u'] = C_u
params['C_d'] = C_d
params['F0'] = F0
params['rmax'] = rmax
params['rmin'] = rmin
params['F0_mean'] = F0_mean
params['F_grad_max'] = F_grad_max
add_params = dict()
add_params['wmin_steps'] = wmin_steps
add_params['k_thr'] = k_thr
add_params['correction_weight'] = correction_weight
mu_1, I1_1, I2_1 = calculate_mu_bar(params, add_params)
time_value1 += mu_1 * integration_dt[n]
time_value_evolution[n + 1] = time_value1
# log_debug(mu_1, 'mu_1')
# log_debug(I1_1, 'I1_1')
# log_debug(I2_1, 'I2_1')
# log_debug(time_value1, 'time value 1')
I1_evolution1[n] = I1_1
I2_evolution1[n] = I2_1
mu_evolution1[n] = mu_1
log_function_exit('integration time loop', start_time=start_time)
log_debug(time_value1, 'final time_value')
# print "approximated time value1 = {:.4g}".format(time_value1)
values.append(time_value1)
log_function_exit('setting {}'.format(num_setting),
start_time=start_time0)
return np.array(values)
def test_formula(nsims=None):
# val_date, dates, cons, model_params, fwd_curve, Fc, delta_F = setting_1()
# val_date, dates, cons, model_params, fwd_curve, Fc, delta_F = setting_2()
val_date, dates, cons, model_params, fwd_curve, Fc, delta_F = setting_3()
Te = calcTe(val_date, dates)
Te_ext = np.append(Te, Te[-1] + 1. / 365.)
nTe = Te.size
fwd_array = fwd_curve.values
# estimate mean forward curve and gradient upper bound
F0_mean = fwd_array.mean()
dt = 1. / 365.
dFdt = np.gradient(fwd_array, dt)
F_grad_rms = rms(dFdt)
F_grad_max = abs(dFdt).max()
results, TP = run_one_valuation_intrinsic(Te, fwd_array, cons)
cashflows = results['cashflows'].spot + results['cashflows'].opex
mean_cf = cashflows.mean(axis=1)
value = mean_cf.sum()
mean_actions = results.actions.mean(axis=1)
print "intrinsic value = {}".format(value)
levels = np.empty(nTe + 1, dtype=float)
levels[0] = cons.start_inv
levels[1:] = cons.start_inv + np.cumsum(mean_actions)
minor_sticks = []
for t in range(nTe)[1:]:
if mean_actions[t] != mean_actions[t - 1]:
minor_sticks.append(Te[t])
triggers = calculate_trigger_prices2(TP['dVdq'], Te, fwd_array,
mean_actions, cons)
# triggers = calculate_trigger_prices(TP['dVdq'], Te, fwd_array, mean_actions, cons)
log_debug(Te, 'Te')
log_debug(Te * 365., 'Te*365')
log_debug(fwd_array, 'fwd_array')
log_debug(triggers.trigger_prices_upper, 'trigger_prices_upper')
log_debug(triggers.trigger_prices_lower, 'trigger_prices_lower')
log_debug(triggers.tt_up * 365., 'tt_up*365')
log_debug(triggers.tt_down * 365., 'tt_down*365')
log_debug(triggers.fdot_up, 'fdot_up')
log_debug(triggers.fdot_down, 'fdot_down')
if nsims is not None and nsims > 0:
stoch_value, stoch_value_error = run_valuation_stochastic(val_date,
dates,
fwd_curve,
cons,
model_params,
nsims=nsims)
print "stoch value = {:.4g} +- {:.4g}".format(stoch_value,
stoch_value_error)
print "time value = {:.4g} +- {:.4g}".format(stoch_value - value,
stoch_value_error)
plt.close('all')
plt.figure()
plt.plot(Te, fwd_array, 'o-', linewidth=1, markersize=2)
plt.plot(Te_ext, levels)
plt.plot(Te, triggers.trigger_prices, 'o-', linewidth=1, markersize=2)
plt.plot(Te, triggers.trigger_prices_upper, '--', linewidth=1)
plt.plot(Te, triggers.trigger_prices_lower, '--', linewidth=1)
ax = plt.gca()
# start, end = ax.get_xlim()
ax.xaxis.set_ticks(minor_sticks, minor=True)
plt.grid(True)
ax.xaxis.grid(True, which='minor')
# plt.show()
# return
#############################################################
if Te_ext[0] > 0:
Num_0_Ta = Te_ext[0] * 365.
tenors_0_Ta = np.linspace(0., Te_ext[0], Num_0_Ta + 1)
tenors_0_Tb = np.append(tenors_0_Ta, Te_ext[1:])
else:
tenors_0_Tb = Te_ext
integration_dt = np.diff(tenors_0_Tb)
log_debug(Te_ext * 365., 'tenors_Ta_Tb*365')
log_debug(tenors_0_Tb * 365., 'tenors_0_Tb*365')
from mkl.interpolation import Interpolate1D
triggers_matrix = np.hstack(
(triggers.trigger_prices_upper.reshape(-1, 1),
triggers.trigger_prices_lower.reshape(-1,
1), fwd_array.reshape(-1, 1)))
trigger_interpolator = Interpolate1D(Te, triggers_matrix, kind='linear')
num_time_steps = tenors_0_Tb.size
rmax = cons.rmax
rmin = cons.rmin
rmax *= 365
rmin *= 365
time_value1 = 0
time_value2 = 0
time_value3 = 0
time_value_evolution = np.zeros(num_time_steps)
I1_evolution1 = np.zeros(num_time_steps - 1)
I2_evolution1 = np.zeros(num_time_steps - 1)
mu_evolution1 = np.zeros(num_time_steps - 1)
I1_evolution2 = np.zeros(num_time_steps - 1)
I2_evolution2 = np.zeros(num_time_steps - 1)
mu_evolution2 = np.zeros(num_time_steps - 1)
for n in range(num_time_steps - 1):
log_function_enter('time loop')
log_debug('time step {} of {}'.format(n, num_time_steps - 1),
std_out=False)
t = tenors_0_Tb[n]
tm = max(t, Te[0])
Tb = tenors_0_Tb[-1]
dt = 1. / 365.
num_steps = int(np.round((Tb - tm) / dt))
num_steps *= 5.
tenors = np.linspace(tm, Tb, num_steps + 1)
log_debug(t * 365., 't*365')
C_all = trigger_interpolator.evaluate(tenors).reshape(-1, 3).T
C_u = C_all[0]
C_d = C_all[1]
F0 = C_all[2]
params = dict()
params['n'] = n
params['t'] = t
params['tenors'] = tenors
params['model_params'] = model_params
params['C_u'] = C_u
params['C_d'] = C_d
params['F0'] = F0
params['rmax'] = rmax
params['rmin'] = rmin
params['F0_mean'] = F0_mean
params['F_grad_max'] = F_grad_max
add_params = dict()
add_params['wmin_steps'] = 10.
add_params['k_thr'] = 0.7
add_params['correction_weight'] = 0.5
mu_1, I1_1, I2_1 = calculate_mu_bar(params, add_params)
mu_2, I1_2, I2_2 = calculate_mu_bar_2(t, model_params, rmax, rmin,
triggers)
time_value1 += mu_1 * integration_dt[n]
time_value2 += mu_2 * integration_dt[n]
time_value_evolution[n + 1] = time_value1
log_debug(mu_1, 'mu_1')
log_debug(I1_1, 'I1_1')
log_debug(I2_1, 'I2_1')
log_debug(time_value1, 'time value 1')
I1_evolution1[n] = I1_1
I2_evolution1[n] = I2_1
mu_evolution1[n] = mu_1
I1_evolution2[n] = I1_2
I2_evolution2[n] = I2_2
mu_evolution2[n] = mu_2
log_function_exit('time loop')
log_debug(time_value1, 'final time_value')
print "approximated time value1 = {:.4g}".format(time_value1)
print "approximated time value2 = {:.4g}".format(time_value2)
# plt.figure()
# plt.plot(tenors_0_Tb, time_value_evolution)
# plt.title('time value')
# plt.grid(True)
plt.figure()
plt.plot(tenors_0_Tb[:-1], mu_evolution1, '--r', label='mu1')
plt.plot(tenors_0_Tb[:-1], I1_evolution1, 'r', label='I1_evolution_1')
plt.plot(tenors_0_Tb[:-1], I2_evolution1, 'r', label='I2_evolution_1')
plt.plot(tenors_0_Tb[:-1], mu_evolution2, '--g', label='mu2')
plt.plot(tenors_0_Tb[:-1],
I1_evolution2,
'g',
linewidth=2,
label='I1_evolution_2')
plt.plot(tenors_0_Tb[:-1], I2_evolution2, 'g', label='I2_evolution_2')
plt.legend(loc='best')
plt.grid(True)
plt.show()
def run_valuation_stochastic(val_date,
dates,
fwd_curve,
cons,
model_params,
nsims=5000):
"""
Calculate stochastic storage with simple constraints
Parameters
----------
Te : maturities
fwd_array:
cons : tuple
(max_inv, min_inv, start_inv, end_inv, inj_cost, rel_cost, rmin, rmax)
Returns
-------
"""
max_inv = cons.max_inv
min_inv = cons.min_inv
start_inv = cons.start_inv
end_inv = cons.end_inv
inj_cost = cons.inj_cost
rel_cost = cons.rel_cost
rmin = cons.rmin
rmax = cons.rmax
sigma_1 = model_params.sigma_1
sigma_2 = model_params.sigma_2
alpha_1 = model_params.alpha_1
alpha_2 = model_params.alpha_2
rho = model_params.rho
alphas = [alpha_1, alpha_2]
sigmas = [sigma_1, sigma_2]
Te = calcTe(val_date, dates)
fc = FlowConstraint(rmin, rmax)
flow_constraints = FlowConstraints(Te[0], fc)
inv_constraints = InventoryConstraints(Te, start_inv, end_inv, max_inv,
min_inv, [flow_constraints])
state_object = StateObject(inv_constraints, num_levels=None)
ls_solver_params = AttrDict(max_basis_order=4,
solver='RegularisedLeastSquaresSolver')
product = LeastSquaresMonteCarloEngine(
state_object,
StorageCashflows(Te, injection_cost=inj_cost,
withdrawal_cost=rel_cost), ls_solver_params)
seed = 123
simulator = MultiFactorSimulator(alphas,
sigmas,
fwd_curve,
rho,
val_date,
seed=seed)
sims_bwd = simulator.simulate_spot(dates, nsims).values
factors_bwd = simulator.stoch_factors
sims_fwd = simulator.simulate_spot(dates, nsims).values
factors_fwd = simulator.stoch_factors
results = product.calc_extrinsic(sims_bwd, sims_fwd, factors_bwd,
factors_fwd)
cashflows = (results['cashflows'].spot +
results['cashflows'].opex).sum(axis=0)
value = cashflows.mean()
value_std = cashflows.std()
value_error = value_std / np.sqrt(nsims)
return value, value_error