def __init__(self,model, keep_auxiliary=True, solve_systems=True, compiler='numpy'):
"something to document"
if isinstance(model, CModel):
return model
self.model = model
self.states = [str(v) for v in model['variables_groups']['states']]
self.controls = [str(v) for v in model['variables_groups']['controls']]
self.shocks = [str(v) for v in model['parameters_ordering']]
self.parameters = [str(v) for v in model['parameters_ordering']]
self.__compiler__ = compiler
if not keep_auxiliary:
[f,g] = model_to_fg(model,solve_systems=solve_systems, compiler=compiler)
self.__f__ = f
self.__g__ = g
else:
[f,g,a] = model_to_fg(model,solve_systems=solve_systems, compiler=compiler)
self.__f__ = f
self.__g__ = g
self.__a__ = a
self.auxiliaries = [str(v) for v in model['variables_groups']['auxiliary']]
self.__f_h__ = []
self.__g_h__ = []
def __init__(self,model, keep_auxiliary=True, solve_systems=True, compiler='numpy'):
"something to document"
from dolo.compiler.compiler_python import GModel
if isinstance(model, CModel):
return model
elif isinstance(model, GModel):
model = model.model
self.model = model
self.states = [str(v) for v in model.symbols_s['states']]
self.controls = [str(v) for v in model.symbols_s['controls']]
self.shocks = [str(v) for v in model.symbols_s['shocks']]
self.parameters = [str(v) for v in model.symbols_s['parameters']]
self.__compiler__ = compiler
if not keep_auxiliary:
[f,g] = model_to_fg(model,solve_systems=solve_systems, compiler=compiler)
self.__f__ = f
self.__g__ = g
else:
[f,g,a] = model_to_fg(model,solve_systems=solve_systems, compiler=compiler)
self.__f__ = f
self.__g__ = g
self.__a__ = a
self.auxiliaries = [str(v) for v in model.symbols_s['auxiliary']]
self.__f_h__ = []
self.__g_h__ = []
def g_h(self, v, p, order=1):
# if self.__g_h__.get(order) is None:
if len(self.__g_h__) == 0:
functions = model_to_fg(self.model, order=order)
for i,f in enumerate(functions):
self.__g_h__[i] = f
return self.__g_h__[order](v,p)
def g_h(self, v, p, order=1):
# if self.__g_h__.get(order) is None:
if len(self.__g_h__) == 0:
functions = model_to_fg(self.model, order=order)
for i,f in enumerate(functions):
self.__g_h__[i] = f
return self.__g_h__[order](v,p)
def __init__(self, model, substitute_auxiliary=False, solve_systems=False):
self.model = model
[f, g] = model_to_fg(model,
substitute_auxiliary=substitute_auxiliary,
solve_systems=solve_systems)
self.f = f
self.g = g
def f_h(self, v, p, order=1):
# if self.__f_h__.get(order) is None:
if len(self.__f_h__) == 0:
functions = model_to_fg(self.model, order=order)
self.__f_h__[order] = functions
return self.__f_h__[order](v,p)
def f_h(self, v, p, order=1):
# if self.__f_h__.get(order) is None:
if len(self.__f_h__) == 0:
functions = model_to_fg(self.model, order=order)
self.__f_h__[order] = functions
return self.__f_h__[order](v,p)
def __init__(self,model,substitute_auxiliary=False, solve_systems=False):
self.model = model
[f,g] = model_to_fg(model,substitute_auxiliary=substitute_auxiliary,solve_systems=solve_systems)
self.f = f
self.g = g
def approximate_controls(cmodel, order=1, lambda_name=None, return_dr=True):
from dolo.symbolic.model import SModel
if not isinstance(cmodel, SModel):
model = cmodel.model
else:
model = cmodel
from dolo.compiler.compiler_functions import model_to_fg
[g_fun, f_fun] = model_to_fg(model, order=order)
# get steady_state
import numpy
states = model.symbols_s['states']
controls = model.symbols_s['controls']
parms = model.calibration['parameters']
sigma = model.calibration['covariances']
states_ss = model.calibration['states']
controls_ss = model.calibration['controls']
shocks_ss = model.calibration['shocks']
f_args_ss = numpy.concatenate( [states_ss, controls_ss, states_ss, controls_ss] )
g_args_ss = numpy.concatenate( [states_ss, controls_ss, shocks_ss] )
f = f_fun( f_args_ss, parms)
g = g_fun( g_args_ss, parms)
if lambda_name:
epsilon = 0.001
sigma_index = [p.name for p in model.parameters].index(lambda_name)
pert_parms = parms.copy()
pert_parms[sigma_index] += epsilon
g_pert = g_fun(g_args_ss, pert_parms)
sig2 = (g_pert[0] - g[0])/epsilon*2
sig2_s = (g_pert[1] - g[1])/epsilon*2
pert_sol = state_perturb(f, g, sigma, sigma2_correction = [sig2, sig2_s] )
else:
g = g_fun( g_args_ss, parms)
pert_sol = state_perturb(f, g, sigma )
n_s = len(states_ss)
n_c = len(controls_ss)
if order == 1:
if return_dr:
S_bar = numpy.array( states_ss )
X_bar = numpy.array( controls_ss )
# add transitions of states to the d.r.
X_s = pert_sol[0]
A = g[1][:,:n_s] + numpy.dot( g[1][:,n_s:n_s+n_c], X_s )
B = g[1][:,n_s+n_c:]
dr = CDR([S_bar, X_bar, X_s])
dr.A = A
dr.B = B
dr.sigma = sigma
return dr
return [controls_ss] + pert_sol
if order == 2:
[[X_s,X_ss],[X_tt]] = pert_sol
X_bar = controls_ss + X_tt/2
if return_dr:
S_bar = states_ss
S_bar = numpy.array(S_bar)
X_bar = numpy.array(X_bar)
dr = CDR([S_bar, X_bar, X_s, X_ss])
A = g[1][:,:n_s] + numpy.dot( g[1][:,n_s:n_s+n_c], X_s )
B = g[1][:,n_s+n_c:]
dr.sigma = sigma
dr.A = A
dr.B = B
return dr
return [X_bar, X_s, X_ss]
if order == 3:
[[X_s,X_ss,X_sss],[X_tt, X_stt]] = pert_sol
X_bar = controls_ss + X_tt/2
X_s = X_s + X_stt/2
if return_dr:
S_bar = states_ss
dr = CDR([S_bar, X_bar, X_s, X_ss, X_sss])
dr.sigma = sigma
return dr
return [X_bar, X_s, X_ss, X_sss]
def approximate_controls(cmodel, order=1, lambda_name=None, return_dr=True):
from dolo.symbolic.model import SModel
if not isinstance(cmodel, SModel):
model = cmodel.model
else:
model = cmodel
from dolo.compiler.compiler_functions import model_to_fg
[g_fun, f_fun] = model_to_fg(model, order=order)
# get steady_state
import numpy
states = model.symbols_s['states']
controls = model.symbols_s['controls']
parms = model.calibration['parameters']
sigma = model.calibration['covariances']
states_ss = model.calibration['states']
controls_ss = model.calibration['controls']
shocks_ss = model.calibration['shocks']
f_args_ss = numpy.concatenate(
[states_ss, controls_ss, states_ss, controls_ss])
g_args_ss = numpy.concatenate([states_ss, controls_ss, shocks_ss])
f = f_fun(f_args_ss, parms)
g = g_fun(g_args_ss, parms)
if lambda_name:
epsilon = 0.001
sigma_index = [p.name for p in model.parameters].index(lambda_name)
pert_parms = parms.copy()
pert_parms[sigma_index] += epsilon
g_pert = g_fun(g_args_ss, pert_parms)
sig2 = (g_pert[0] - g[0]) / epsilon * 2
sig2_s = (g_pert[1] - g[1]) / epsilon * 2
pert_sol = state_perturb(f, g, sigma, sigma2_correction=[sig2, sig2_s])
else:
g = g_fun(g_args_ss, parms)
pert_sol = state_perturb(f, g, sigma)
n_s = len(states_ss)
n_c = len(controls_ss)
if order == 1:
if return_dr:
S_bar = numpy.array(states_ss)
X_bar = numpy.array(controls_ss)
# add transitions of states to the d.r.
X_s = pert_sol[0]
A = g[1][:, :n_s] + numpy.dot(g[1][:, n_s:n_s + n_c], X_s)
B = g[1][:, n_s + n_c:]
dr = CDR([S_bar, X_bar, X_s])
dr.A = A
dr.B = B
dr.sigma = sigma
return dr
return [controls_ss] + pert_sol
if order == 2:
[[X_s, X_ss], [X_tt]] = pert_sol
X_bar = controls_ss + X_tt / 2
if return_dr:
S_bar = states_ss
S_bar = numpy.array(S_bar)
X_bar = numpy.array(X_bar)
dr = CDR([S_bar, X_bar, X_s, X_ss])
A = g[1][:, :n_s] + numpy.dot(g[1][:, n_s:n_s + n_c], X_s)
B = g[1][:, n_s + n_c:]
dr.sigma = sigma
dr.A = A
dr.B = B
return dr
return [X_bar, X_s, X_ss]
if order == 3:
[[X_s, X_ss, X_sss], [X_tt, X_stt]] = pert_sol
X_bar = controls_ss + X_tt / 2
X_s = X_s + X_stt / 2
if return_dr:
S_bar = states_ss
dr = CDR([S_bar, X_bar, X_s, X_ss, X_sss])
dr.sigma = sigma
return dr
return [X_bar, X_s, X_ss, X_sss]
