def __init__(self, statespace, all_names,
xw_sym_dicts={}, ss_x_sol_dict={}, par_to_values_dict={},
eq_conditions=[], utility=[], xss_ini_dict={}, theta=3.0):
self.statespace = statespace
self.A_num = statespace.A_num
self.C_num = statespace.C_num
self.D_num = statespace.D_num
self.G_num = statespace.G_num
self.par_to_values_dict = par_to_values_dict
self.x_names = all_names['x_names']
self.w_names = all_names['w_names']
self.param_names = all_names['param_names']
self.q = sympy.Symbol('q')
self.utility = utility
self.beta = sympy.Symbol('beta')
self.theta = theta
self.psi_x = None
self.psi_w = None
self.psi_q = None
self.psi_x_x = None
self.psi_x_w = None
self.psi_x_q = None
self.psi_w_w = None
self.psi_w_q = None
self.psi_q_q = None
self.param_sym_dict = utils.make_param_sym_dict(self.param_names)
if xw_sym_dicts == {}:
self.xw_sym_dicts = utils.set_x_w_sym_dicts(self.x_names, self.w_names)
else:
self.xw_sym_dicts = xw_sym_dicts
self.x_s_d, self.w_s_d = self.xw_sym_dicts
self.normal_x_s_d = {st: self.x_s_d[st] for st in self.x_s_d.keys() if
not ('_q' in st or '_1' in st or '_2' in st or '_0' in st
or 'ss' in st or 'q' in st)}
self.normal_x_s_tp1 = {st: self.normal_x_s_d[st] for st in self.normal_x_s_d.keys() if
'tp1' in st}
self.normal_x_s_t = {st: self.normal_x_s_d[st] for st in self.normal_x_s_d.keys() if
not('tm1' in st or 'tp1' in st)}
self.normal_x_s_tm1 = {st: self.normal_x_s_d[st] for st in self.normal_x_s_d.keys() if
'tm1' in st}
self.normal_w_s_d = {st: self.w_s_d[st] for st in self.w_s_d.keys() if
not 'ss' in st}
self.normal_w_s_tp1 = {st: self.normal_w_s_d[st] for st in self.normal_w_s_d.keys() if
'tp1' in st}
self.normal_w_s_t = {st: self.normal_w_s_d[st] for st in self.normal_w_s_d.keys() if
not('tm1' in st or 'tp1' in st)}
self.xvar_tp1_sym = self.normal_x_s_tp1.values()
self.xvar_t_sym = self.normal_x_s_t.values()
self.xvar_tm1_sym = self.normal_x_s_tm1.values()
self.wvar_tp1_sym = self.normal_w_s_tp1.values()
self.wvar_t_sym = self.normal_w_s_t.values()
self.xvar_tp1_sym = list(sympy.ordered(self.xvar_tp1_sym))
self.xvar_t_sym = list(sympy.ordered(self.xvar_t_sym))
self.xvar_tm1_sym = list(sympy.ordered(self.xvar_tm1_sym))
self.wvar_tp1_sym = list(sympy.ordered(self.wvar_tp1_sym))
self.wvar_t_sym = list(sympy.ordered(self.wvar_t_sym))
self.normal_xw_to_q = utils.make_normal_to_q_dict(self.x_names, self.w_names)
self.normal_and_0_to_ss = utils.make_normal_to_steady_state(
self.x_names, self.w_names)
self.x_in_ss_sym_d = {st: self.x_s_d[st]
for st in self.x_s_d.keys() if 'ss' in st}
self.w_in_ss_zero_d = utils.make_wss_to_zero_dict(self.w_names)
self.qdiffs_to_012_d = utils.make_qdiff_to_q012(self.x_names)
self.eq_conditions = eq_conditions
print "in init, self.eq_conditions", self.eq_conditions
self.d_g_dxw_1, self.d_g_dxw_2 = self.d1d2_g_x_w_unevaluated()
self.fun_d_first_numpy = None
self.fun_d_second_numpy = None
self.Need_compile_theano_fn_first = False
self.Need_compile_theano_fn_second = False
if par_to_values_dict != {}:
self.eq_conditions_nopar = [
x.subs(par_to_values_dict) for x in self.eq_conditions]
self.eq_conditions_nopar_ss = [x.subs(self.normal_and_0_to_ss).subs(
self.w_in_ss_zero_d) for x in self.eq_conditions_nopar]
self.eq_conditions_matrix = sympy.Matrix(self.eq_conditions)
symbols_per_eq_nopar = [
g.atoms(sympy.Symbol) for g in self.eq_conditions_nopar]
self.xw_symbols_eq_cond_nopar = list(
set.union(*symbols_per_eq_nopar))
if ss_x_sol_dict == {}:
self.ss_solutions_dict = utils.get_sstate_sol_dict_from_sympy_eqs(
self.eq_conditions_nopar_ss,
self.x_in_ss_sym_d,
xini_dict=xss_ini_dict)
else:
self.ss_solutions_dict = ss_x_sol_dict
self.xss_ini_dict = self.ss_solutions_dict
normal_x_s_tp1_ss_values = [x.subs(self.normal_and_0_to_ss).subs(self.ss_solutions_dict)
for x in self.normal_x_s_tp1.values()]
self.normal_x_s_tp1_ss_values_d = dict(
zip(self.normal_x_s_tp1.values(), normal_x_s_tp1_ss_values))
normal_x_s_t_ss_values = [x.subs(self.normal_and_0_to_ss).subs(self.ss_solutions_dict)
for x in self.normal_x_s_t.values()]
self.normal_x_s_t_ss_values_d = dict(
zip(self.normal_x_s_t.values(), normal_x_s_t_ss_values))
normal_x_s_tm1_ss_values = [x.subs(self.normal_and_0_to_ss).subs(self.ss_solutions_dict)
for x in self.normal_x_s_tm1.values()]
self.normal_x_s_tm1_ss_values_d = dict(
zip(self.normal_x_s_tm1.values(), normal_x_s_tm1_ss_values))
self.normal_x_s_ss_values_d = {}
self.normal_x_s_ss_values_d.update(self.normal_x_s_tp1_ss_values_d)
self.normal_x_s_ss_values_d.update(self.normal_x_s_t_ss_values_d)
self.normal_x_s_ss_values_d.update(self.normal_x_s_tm1_ss_values_d)
self.normal_w_tp1_s_zero_pairs = [
(x, 0) for x in self.normal_w_s_d.values()]
self.normal_w_s_ss_values_d = dict(self.normal_w_tp1_s_zero_pairs)
self.normal_xw_s_ss_values_d = {}
self.normal_xw_s_ss_values_d.update(self.normal_x_s_ss_values_d)
self.normal_xw_s_ss_values_d.update(self.normal_w_s_ss_values_d)
# args_values_x = [x.subs(self.normal_x_s_ss_values_d)
# for x in self.normal_x_s_d.values()]
self.args_values_xtp1ss = [x.subs(self.normal_x_s_tp1_ss_values_d)
for x in self.xvar_tp1_sym]
self.args_values_xtss = [x.subs(self.normal_x_s_t_ss_values_d)
for x in self.xvar_t_sym]
self.args_values_xtm1ss = [x.subs(self.normal_x_s_tm1_ss_values_d)
for x in self.xvar_tm1_sym]
self.args_values_x = (self.args_values_xtp1ss +
self.args_values_xtss + self.args_values_xtm1ss)
args_values_wtss = [w.subs(self.normal_w_s_ss_values_d)
for w in self.wvar_t_sym]
args_values_wtp1ss = [w.subs(self.normal_w_s_ss_values_d)
for w in self.wvar_tp1_sym]
args_values_w = args_values_wtss + args_values_wtp1ss
args_values_p = [p.subs(par_to_values_dict)
for p in self.param_sym_dict.values()]
self.args_values = self.args_values_x + args_values_w + args_values_p
def old_get_evaluated_dgdxw12(self, eq_system=[], param_vals_d={}, mod='numpy'):
if eq_system == []:
# print '\nyes'
eqs = self.eq_conditions
print "len(eqs)" ,len(eqs)
print "eqs:", eqs
d_g_dxw_1, d_g_dxw_2 = self.d_g_dxw_1, self.d_g_dxw_2
if param_vals_d == {}:
# print '\nyes again'
param_vals_d = self.par_to_values_dict
ss_sol_dict = self.ss_solutions_dict
args_values = self.args_values
else:
print '\nsame eqs, different par_vals'
eqs_nopar = [x.subs(param_vals_d) for x in eqs]
eqs_nopar_ss = [x.subs(self.normal_and_0_to_ss).subs(self.w_in_ss_zero_d)
for x in eqs_nopar]
ss_sol_dict = get_sstate_sol_dict_from_sympy_eqs(
eqs_nopar_ss, self.x_in_ss_sym_d,
xini_dict=self.xss_ini_dict)
normal_x_s_tp1_ss_values = [x.subs(self.normal_and_0_to_ss).subs(ss_sol_dict)
for x in self.normal_x_s_tp1.values()]
normal_x_s_tp1_ss_values_d = dict(
zip(self.normal_x_s_tp1.values(), normal_x_s_tp1_ss_values))
normal_x_s_t_ss_values = [x.subs(self.normal_and_0_to_ss).subs(ss_sol_dict)
for x in self.normal_x_s_t.values()]
normal_x_s_t_ss_values_d = dict(
zip(self.normal_x_s_t.values(), normal_x_s_t_ss_values))
normal_x_s_tm1_ss_values = [x.subs(self.normal_and_0_to_ss).subs(ss_sol_dict)
for x in self.normal_x_s_tm1.values()]
normal_x_s_tm1_ss_values_d = dict(
zip(self.normal_x_s_tm1.values(), normal_x_s_tm1_ss_values))
normal_x_s_ss_values_d = {}
normal_x_s_ss_values_d.update(normal_x_s_tp1_ss_values_d)
normal_x_s_ss_values_d.update(normal_x_s_t_ss_values_d)
normal_x_s_ss_values_d.update(normal_x_s_tm1_ss_values_d)
normal_w_tp1_s_zero_pairs = [(x, 0)
for x in self.normal_w_s_d.values()]
normal_w_s_ss_values_d = dict(normal_w_tp1_s_zero_pairs)
args_values_x = [x.subs(normal_x_s_ss_values_d)
for x in self.normal_x_s_d.values()]
args_values_w = [w.subs(normal_w_s_ss_values_d)
for w in self.normal_w_s_d.values()]
args_values_p = [p.subs(param_vals_d)
for p in self.param_sym_dict.values()]
args_values = args_values_x + args_values_w + args_values_p
else:
print 'nooooo, different eqs'
eqs = eq_system
d_g_dxw_1, d_g_dxw_2 = self.d1d2_g_x_w_unevaluated()
if param_vals_d == {}:
param_vals_d = self.par_to_values_dict
else:
print '\ndifferent eqs, different par_vals'
eqs_nopar = [x.subs(param_vals_d) for x in eqs]
eqs_nopar_ss = [x.subs(self.normal_and_0_to_ss).subs(self.w_in_ss_zero_d)
for x in eqs_nopar]
ss_sol_dict = utils.get_sstate_sol_dict_from_sympy_eqs(
eqs_nopar_ss, self.x_in_ss_sym_d,
xini_dict=self.xss_ini_dict)
normal_x_s_tp1_ss_values = [x.subs(self.normal_and_0_to_ss).subs(ss_sol_dict)
for x in self.normal_x_s_tp1.values()]
normal_x_s_tp1_ss_values_d = dict(
zip(self.normal_x_s_tp1.values(), normal_x_s_tp1_ss_values))
normal_x_s_t_ss_values = [x.subs(self.normal_and_0_to_ss).subs(ss_sol_dict)
for x in self.normal_x_s_t.values()]
normal_x_s_t_ss_values_d = dict(
zip(self.normal_x_s_t.values(), normal_x_s_t_ss_values))
normal_x_s_tm1_ss_values = [x.subs(self.normal_and_0_to_ss).subs(ss_sol_dict)
for x in self.normal_x_s_tm1.values()]
normal_x_s_tm1_ss_values_d = dict(
zip(self.normal_x_s_tm1.values(), normal_x_s_tm1_ss_values))
normal_x_s_ss_values_d = {}
normal_x_s_ss_values_d.update(normal_x_s_tp1_ss_values_d)
normal_x_s_ss_values_d.update(normal_x_s_t_ss_values_d)
normal_x_s_ss_values_d.update(normal_x_s_tm1_ss_values_d)
normal_w_tp1_s_zero_pairs = [(x, 0)
for x in self.normal_w_s_d.values()]
normal_w_s_ss_values_d = dict(normal_w_tp1_s_zero_pairs)
args_values_x = [x.subs(normal_x_s_ss_values_d)
for x in self.normal_x_s_d.values()]
args_values_w = [w.subs(normal_w_s_ss_values_d)
for w in self.normal_w_s_d.values()]
args_values_p = [p.subs(param_vals_d)
for p in self.param_sym_dict.values()]
args_values = args_values_x + args_values_w + args_values_p
if mod == 'numpy':
if self.fun_d_first_numpy == None or self.fun_d_second_numpy == None:
self.fun_d_first_numpy, self.fun_d_second_numpy, vals = self.make_numpy_fns_of_d1d2xw(
d_g_dxw_1, d_g_dxw_2)
d_first = self.fun_d_first_numpy(*args_values)
d_second = self.fun_d_second_numpy(*args_values)
d_first = [np.array(d, dtype='float') for d in d_first]
d_second = [np.array(d, dtype='float') for d in d_second]
print 'hey! I\'m using a numpy function!'
return d_first, d_second
elif mod == 'theano':
if self.Need_compile_theano_fn_first:
fn_d_first_th, fn_d_second_th, valth = self.make_theano_fns_of_d1d2xw(
d_g_dxw_1, d_g_dxw_2)
d_first = fn_d_first_th(*args_values)
d_second = fn_d_second_th(*args_values)
return d_first, d_second
else:
print "Must specify 'numpy' or 'theano' "
