def find_steady_state(hmodel, dr0=None, verbose=True, distribs=None):
m0 = hmodel.calibration['exogenous']
y0 = hmodel.calibration['aggregate']
p = hmodel.calibration['parameters']
if dr0 is None:
if verbose: print("Computing Initial Initial Rule... ", end="")
dr0 = hmodel.get_starting_rule()
if verbose: print(colored("done", "green"))
if verbose: print("Computing Steady State...", end="")
if distribs is None:
dist = [(1.0, {})]
if not hmodel.features['ex-ante-identical']:
dist = distribs = discretize_idiosyncratic_shocks(
hmodel.distribution)
else:
dist = distribs
def fun(u):
res = y0 * 0
for w, kwargs in dist:
hmodel.model.set_calibration(**kwargs)
res += w * equilibrium(
hmodel, m0, u, dr0=dr0, return_equilibrium=False)
return res
solution = scipy.optimize.root(fun, x0=y0)
if not solution.success:
if verbose: print(colored("failed", "red"))
else:
if verbose: print(colored("done", "green"))
# grid_m = model.exogenous.discretize(to='mc', options=[{},{'N':N_mc}]).nodes()
# grid_s = model.get_grid().nodes()
#
y_ss = solution.x # vector of aggregate endogenous variables
m_ss = m0 # vector fo aggregate exogenous
eqs = []
for w, kwargs in (dist):
hmodel.model.set_calibration(**kwargs)
(res_ss, sol_ss, μ_ss, Π_ss) = equilibrium(hmodel,
m_ss,
y_ss,
p,
dr0,
return_equilibrium=True)
μ_ss = μ_ss.data
dr_ss = sol_ss.dr
eqs.append([w, Equilibrium(hmodel, m_ss, μ_ss, sol_ss.dr, y_ss)])
if distribs is None:
return eqs[0][1]
else:
return eqs
def perturb(hmodel, eq, verbose=True):
from dolo.algos.perturbation import approximate_1st_order
if verbose: print("Computing Jacobian...", end="")
g_s, g_x, g_e, f_s, f_x, f_S, f_X = get_derivatives(hmodel, eq)
if verbose: print(colored("done", "green"))
if verbose: print("Solving Perturbation...", end="")
C0, evs = approximate_1st_order(g_s, g_x, g_e, f_s, f_x, f_S, f_X)
if verbose: print(colored("done", "green"))
C = C0
P = g_s + g_x @ C0
return PerturbedEquilibrium(eq, C, P, evs)
def perturb(hmodel, eq, verbose=True, return_system=False):
# get first order model
if verbose:
print("Computing Jacobian...", end="")
fom = get_derivatives(hmodel, eq)
if verbose:
print(colored("done", "green"))
if verbose:
print("Solving Perturbation...", end="")
C_m, C_s, evs = solve_fom(fom)
if verbose:
print(colored("done", "green"))
return PerturbedEquilibrium(eq, fom, C_m, C_s, evs)
def find_steady_state(hmodel,
dr0=None,
verbose=True,
distribs=None,
return_fun=False):
m0 = hmodel.calibration["exogenous"]
X0 = hmodel.calibration["aggregate"]
p = hmodel.calibration["parameters"]
if dr0 is None:
if verbose:
print("Computing Initial Rule... ", end="")
dr0 = hmodel.get_starting_rule()
if verbose:
print(colored("done", "green"))
if verbose:
print("Computing Steady State...", end="")
if distribs is None:
dist = [(1.0, {})]
if not hmodel.features["ex-ante-identical"]:
dist = distribs = discretize_idiosyncratic_shocks(
hmodel.distribution)
else:
dist = distribs
if hmodel.features["with-aggregate-states"]:
S0 = hmodel.calibration["states"]
n_S = len(S0)
n_X = len(X0)
def fun(u):
res_X = X0 * 0
for w, kwargs in dist:
hmodel.model.set_calibration(**kwargs)
res_X += w * equilibrium(hmodel,
m0,
S0=u[:n_S],
X0=u[n_S:],
dr0=dr0,
return_equilibrium=False)
res_S = transition_residual(hmodel, m0, u[:n_S], u[n_S:])
res = np.concatenate((res_S, res_X))
if verbose == 'full':
print(f"Value at {u} | {res}")
return res
Y0 = np.concatenate((S0, X0))
if return_fun:
return (fun, Y0)
solution = scipy.optimize.root(fun, x0=Y0)
else:
def fun(u):
res = X0 * 0
for w, kwargs in dist:
hmodel.model.set_calibration(**kwargs)
res += w * equilibrium(
hmodel, m0, X0=u, dr0=dr0, return_equilibrium=False)
if verbose == 'full':
print(f"Value at {u} | {res}")
return res
if return_fun:
return (fun, X0)
solution = scipy.optimize.root(fun, x0=X0)
if not solution.success:
if verbose:
print(colored("failed", "red"))
else:
if verbose:
print(colored("done", "green"))
# grid_m = model.exogenous.discretize(to='mc', options=[{},{'N':N_mc}]).nodes
# grid_s = model.get_grid().nodes
#
Y_ss = solution.x # vector of aggregate endogenous variables
m_ss = m0 # vector fo aggregate exogenous
eqs = []
if hmodel.features["with-aggregate-states"]:
for w, kwargs in dist:
hmodel.model.set_calibration(**kwargs)
(res_ss, sol_ss, μ_ss, Π_ss) = equilibrium(
hmodel,
m_ss,
X0=Y_ss[n_S:],
p=p,
dr0=dr0,
S0=Y_ss[:n_S],
return_equilibrium=True,
)
μ_ss = μ_ss.data
dr_ss = sol_ss.dr
eqs.append([
w,
Equilibrium(hmodel,
m_ss,
μ_ss,
sol_ss.dr,
Y_ss[:n_S],
S=Y_ss[:n_S]),
])
else:
for w, kwargs in dist:
hmodel.model.set_calibration(**kwargs)
(res_ss, sol_ss, μ_ss, Π_ss) = equilibrium(hmodel,
m_ss,
X0=Y_ss,
p=p,
dr0=dr0,
return_equilibrium=True)
μ_ss = μ_ss.data
dr_ss = sol_ss.dr
eqs.append([w, Equilibrium(hmodel, m_ss, μ_ss, sol_ss.dr, Y_ss)])
if distribs is None:
return eqs[0][1]
else:
return eqs