def solve_recursive_block(equations):
from dolo.symbolic.symbolic import Equation
system = {eq.lhs: eq.rhs for eq in equations}
from dolo.misc.triangular_solver import solve_triangular_system
sol = solve_triangular_system(system)
solved_equations = [Equation(eq.lhs, sol[eq.lhs]) for eq in equations]
return solved_equations
def read_calibration(self, to_numpy=True):
model = self
from dolo.misc.triangular_solver import solve_triangular_system
dvars = dict()
dvars.update(model.parameters_values)
dvars.update(model.init_values)
for v in model.variables:
if v not in dvars:
dvars[v] = 0
undeclared_parameters = []
for p in model.parameters:
if p not in dvars:
undeclared_parameters.append(p)
dvars[p] = 0
raise Warning(
'No initial value for parameters : ' +
str.join(', ', [p.name for p in undeclared_parameters]))
values = solve_triangular_system(dvars)
y = [values[v] for v in model.variables]
x = [0 for s in model.shocks]
params = [values[v] for v in model.parameters]
resp = [y, x, params]
if to_numpy:
import numpy
return [numpy.array(e, dtype=numpy.float64) for e in resp]
else:
return resp
def read_calibration(self,to_numpy=True):
model = self
from dolo.misc.triangular_solver import solve_triangular_system
dvars = dict()
dvars.update(model.parameters_values)
dvars.update(model.init_values)
for v in model.variables:
if v not in dvars:
dvars[v] = 0
undeclared_parameters = []
for p in model.parameters:
if p not in dvars:
undeclared_parameters.append(p)
dvars[p] = 0
raise Warning('No initial value for parameters : ' + str.join(', ', [p.name for p in undeclared_parameters]) )
values = solve_triangular_system(dvars)
y = [values[v] for v in model.variables]
x = [0 for s in model.shocks]
params = [values[v] for v in model.parameters]
resp = [y,x,params]
if to_numpy:
import numpy
return [numpy.array(e, dtype=numpy.float64) for e in resp]
else:
return resp
def solve_recursive_block(equations):
from dolo.symbolic.symbolic import Equation
system = {eq.lhs: eq.rhs for eq in equations}
from dolo.misc.triangular_solver import solve_triangular_system
sol = solve_triangular_system(system)
solved_equations = [Equation(eq.lhs, sol[eq.lhs]) for eq in equations]
return solved_equations
def test_solve_symbolic_system(self):
from dolo.misc.triangular_solver import solve_triangular_system
import sympy
[w, x, y, z, t] = vars = sympy.symbols('w, x, y, z, t')
eqs = [x + y + z + t, y + z, z, 1, 1]
sdict = {s: eqs[i] for i, s in enumerate(vars)}
solution = solve_triangular_system(sdict)
assert (solution[z] == 1)
assert (solution[t] == 1)
assert (solution[y] == 1)
assert (solution[x] == 2)
assert (solution[w] == 5)
def update(self):
"""Propagates changes in symbolic structure"""
self.symbols = OrderedDict(
(k, tuple(str(h) for h in v)) for k, v in self.symbols_s.iteritems()
) # dict: string -> (list: sympy)
l = []
for e in self.symbols_s.keys():
if e not in ("shocks", "parameters"):
l.extend(self.symbols_s[e])
# for backward compatibility
self.variables = l
self.shocks = self.symbols_s["shocks"]
self.parameters = self.symbols_s["parameters"]
# update calibration
from dolo.misc.triangular_solver import solve_triangular_system
calibration_dict = solve_triangular_system(self.calibration_s) # calibration dict : sympy -> float
self.calibration_dict = calibration_dict
calibration = OrderedDict() # calibration dict (by group) : string -> ( sympy -> float )
for vg in self.symbols_s:
vars = self.symbols_s[vg]
values = [(float(calibration_dict[v]) if v in calibration_dict else nan) for v in vars]
calibration[vg] = numpy.array(values, dtype=floatX)
sigma = self.covariances_s.subs(self.calibration_s)
sigma = numpy.array(sigma).astype(floatX)
calibration["covariances"] = sigma
self.calibration = calibration
self.sigma = sigma
l = []
for eqg, eq in self.equations_groups.iteritems():
l.extend(eq)
self.equations = l
def update(self):
'''Propagates changes in symbolic structure'''
self.symbols = OrderedDict( (k, tuple(str(h) for h in v) ) for k,v in self.symbols_s.iteritems() ) # dict: string -> (list: sympy)
l = []
for e in self.symbols_s.keys():
if e not in ('shocks','parameters'):
l.extend(self.symbols_s[e])
# for backward compatibility
self.variables = l
self.shocks = self.symbols_s['shocks']
self.parameters = self.symbols_s['parameters']
# update calibration
from dolo.misc.triangular_solver import solve_triangular_system
calibration_dict = solve_triangular_system(self.calibration_s) # calibration dict : sympy -> float
self.calibration_dict = calibration_dict
calibration = OrderedDict() # calibration dict (by group) : string -> ( sympy -> float )
for vg in self.symbols_s:
vars = self.symbols_s[vg]
values = [ (float(calibration_dict[v]) if v in calibration_dict else nan) for v in vars]
calibration[vg] = numpy.array( values, dtype=floatX )
sigma = self.covariances_s.subs(self.calibration_s)
sigma = numpy.array( sigma ).astype( floatX )
calibration['covariances'] = sigma
self.calibration = calibration
self.sigma = sigma
l = []
for eqg,eq in self.equations_groups.iteritems():
l.extend(eq)
self.equations = l
def read_covariances(self, to_numpy=True):
# TODO: we could return a dict instead
# duplicated code
model = self
from dolo.misc.triangular_solver import solve_triangular_system
dvars = dict()
dvars.update(model.parameters_values)
dvars.update(model.init_values)
for v in model.variables:
if v not in dvars:
dvars[v] = 0
undeclared_parameters = []
for p in model.parameters:
if p not in dvars:
undeclared_parameters.append(p)
dvars[p] = 0
raise Warning(
'No initial value for parameters : ' +
str.join(', ', [p.name for p in undeclared_parameters]))
values = solve_triangular_system(dvars)
if 'covariances' in self and self['covariances'] is not None:
m = self['covariances']
m = m.subs(values)
else:
m = sympy.zeros((len(self.shocks), ) * 2)
import numpy
resp = numpy.array(m).astype(numpy.float)
if to_numpy:
import numpy
return numpy.array(resp, dtype=numpy.float64)
else:
return resp
def test_solve_symbolic_system(self):
from dolo.misc.triangular_solver import solve_triangular_system
import sympy
[w,x,y,z,t] = vars = sympy.symbols('w, x, y, z, t')
eqs = [
x + y + z + t,
y + z,
z,
1,
1
]
sdict = {s:eqs[i] for i,s in enumerate(vars) }
solution = solve_triangular_system(sdict)
assert(solution[z]==1)
assert(solution[t]==1)
assert(solution[y]==1)
assert(solution[x]==2)
assert(solution[w]==5)
def read_covariances(self,to_numpy=True):
# TODO: we could return a dict instead
# duplicated code
model = self
from dolo.misc.triangular_solver import solve_triangular_system
dvars = dict()
dvars.update(model.parameters_values)
dvars.update(model.init_values)
for v in model.variables:
if v not in dvars:
dvars[v] = 0
undeclared_parameters = []
for p in model.parameters:
if p not in dvars:
undeclared_parameters.append(p)
dvars[p] = 0
raise Warning('No initial value for parameters : ' + str.join(', ', [p.name for p in undeclared_parameters]) )
values = solve_triangular_system(dvars)
if 'covariances' in self and self['covariances'] is not None:
m = self['covariances']
m = m.subs(values)
else:
m = sympy.zeros( (len(self.shocks),)*2 )
import numpy
resp = numpy.array(m).astype(numpy.float)
if to_numpy:
import numpy
return numpy.array(resp, dtype=numpy.float64)
else:
return resp
def simple_global_representation(self,
allow_future_shocks=True,
solve_systems=False):
resp = {}
eq_g = self.equations_groups
v_g = self.symbols_s
if 'expectation' in eq_g:
resp['f_eqs'] = [
eq.gap for eq in eq_g['arbitrage'] + eq_g['expectation']
] # TODO: complementarity conditions
resp['controls'] = v_g['controls'] + v_g['expectations']
else:
resp['f_eqs'] = [eq.gap for eq in eq_g['arbitrage']
] # TODO: complementarity conditions
resp['controls'] = list(v_g['controls'])
resp['g_eqs'] = [eq.rhs for eq in eq_g['transition']]
if 'auxiliary' in eq_g:
sdict = {}
from dolo.symbolic.symbolic import timeshift
auxies = list(eq_g['auxiliary'])
if 'auxiliary_2' in eq_g:
auxies += list(eq_g['auxiliary_2'])
for eq in auxies:
sdict[eq.lhs] = eq.rhs
sdict[eq.lhs(1)] = timeshift(eq.rhs, 1)
sdict[eq.lhs(-1)] = timeshift(eq.rhs, -1)
from dolo.misc.triangular_solver import solve_triangular_system
sdict = solve_triangular_system(sdict)
resp['a_eqs'] = [sdict[v] for v in v_g['auxiliary']]
resp['auxiliaries'] = [v for v in v_g['auxiliary']]
resp['f_eqs'] = [eq.subs(sdict) for eq in resp['f_eqs']]
resp['g_eqs'] = [eq.subs(sdict) for eq in resp['g_eqs']]
elif 'auxiliary_2' in eq_g:
sdict = {}
from dolo.misc.misc import timeshift
auxies = eq_g['auxiliary_2']
for eq in auxies:
sdict[eq.lhs] = eq.rhs
sdict[eq.lhs(1)] = timeshift(eq.rhs, 1)
sdict[eq.lhs(-1)] = timeshift(eq.rhs, -1)
from dolo.misc.calculus import simple_triangular_solve
sdict = simple_triangular_solve(sdict)
resp['f_eqs'] = [eq.subs(sdict) for eq in resp['f_eqs']]
resp['g_eqs'] = [eq.subs(sdict) for eq in resp['g_eqs']]
if not allow_future_shocks:
# future shocks are replaced by 0
zero_shocks = {s(1): 0 for s in self.shocks}
resp['f_eqs'] = [eq.subs(zero_shocks) for eq in resp['f_eqs']]
if solve_systems:
from dolo.misc.triangular_solver import solve_triangular_system
system = {s: resp['g_eqs'][i] for i, s in enumerate(v_g['states'])}
new_geqs = solve_triangular_system(system)
resp['g_eqs'] = [new_geqs[s] for s in v_g['states']]
resp['states'] = v_g['states']
resp['shocks'] = self.shocks #['shocks_ordering'] # TODO: bad
resp['parameters'] = self.parameters #['parameters_ordering']
return resp
]
from sympy import exp
eqs = [
x + y*k_2 + z*exp(x_1 + t),
(y + z)**0.3,
z,
(k_1 + k_2)**0.3,
k_2**x_1
]
sdict = {s:eqs[i] for i,s in enumerate(vars) }
from dolo.misc.triangular_solver import solve_triangular_system
order = solve_triangular_system(sdict, return_order=True)
ordered_vars = [ v for v in order ]
ordered_eqs = [ eqs[vars.index(v)] for v in order ]
pprint(ordered_vars)
pprint(ordered_eqs)
import numpy
floatX = numpy.float32
s0 = numpy.array( [2,5], dtype=floatX)
x0 = numpy.array( [2,2], dtype=floatX)
p0 = numpy.array( [4,3], dtype=floatX)
def export_to_modfile(
self, output_file=None, return_text=False, options={}, append="", comments="", solve_init_state=False
):
model = self.model
# init_state = self.get_init_dict()
default = {"steady": False, "check": False, "dest": "dynare", "order": 1, "use_dll": False} # default options
for o in default:
if not o in options:
options[o] = default[o]
init_block = ["// Generated by Dolo"]
init_block.append("// Model basename : " + self.model.fname)
init_block.append(comments)
init_block.append("")
init_block.append("var " + str.join(",", map(str, self.model.variables)) + ";")
init_block.append("")
init_block.append("varexo " + str.join(",", map(str, self.model.shocks)) + ";")
init_block.append("")
init_block.append("parameters " + str.join(",", map(str, self.model.parameters)) + ";")
init_state = model.parameters_values.copy()
init_state.update(model.init_values.copy())
from dolo.misc.triangular_solver import solve_triangular_system
if not solve_init_state:
itd = model.init_values
order = solve_triangular_system(init_state, return_order=True)
else:
itd, order = solve_triangular_system(init_state)
for p in order:
if p in model.parameters:
# init_block.append(p.name + " = " + str(init_state[p]) + ";")
if p in model.parameters_values:
init_block.append(p.name + " = " + str(model.parameters_values[p]).replace("**", "^") + ";")
printer = CustomPrinter()
model_block = []
if options["use_dll"]:
model_block.append("model(use_dll);")
else:
model_block.append("model;")
for eq in self.model.equations:
s = printer.doprint(eq)
s = s.replace("==", "=")
s = s.replace("**", "^")
# s = s.replace("_b1","(-1)") # this should allow lags more than 1
# s = s.replace("_f1","(+1)") # this should allow lags more than 1
model_block += "\n"
if "name" in eq.tags:
model_block.append("// eq %s : %s" % (eq.n, eq.tags.get("name")))
else:
model_block.append("// eq %s" % (eq.n))
if len(eq.tags) > 0:
model_block.append("[ {0} ]".format(" , ".join(["{0} = '{1}'".format(k, eq.tags[k]) for k in eq.tags])))
model_block.append(s + ";")
model_block.append("end;")
if options["dest"] == "dynare":
shocks_block = []
if model.covariances != None:
shocks_block.append("shocks;")
cov_shape = model.covariances.shape
for i in range(cov_shape[0]):
for j in range(i, cov_shape[1]):
cov = model.covariances[i, j]
if cov != 0:
tcov = str(cov).replace("**", "^")
if i == j:
shocks_block.append("var " + str(self.model.shocks[i]) + " = " + tcov + " ;")
else:
shocks_block.append(
"var "
+ str(self.model.shocks[i])
+ ","
+ str(self.model.shocks[j])
+ " = "
+ tcov
+ " ;"
)
shocks_block.append("end;")
elif options["dest"] == "dynare++":
shocks_block = []
shocks_block.append("vcov = [")
cov_shape = self.covariances.shape
shocks_matrix = []
for i in range(cov_shape[0]):
shocks_matrix.append(" ".join(map(str, self.covariances[i, :])))
shocks_block.append(";\n".join(shocks_matrix))
shocks_block.append("];")
initval_block = []
if len(model.init_values) > 0:
initval_block.append("initval;")
for v in order:
if v in model.init_values:
initval_block.append(str(v) + " = " + str(itd[v]).replace("**", "^") + ";")
elif options["dest"] == "dynare++":
# dynare++ doesn't default to zero for non initialized variables
initval_block.append(str(v) + " = 0 ;")
initval_block.append("end;")
# else:
# itd = self.get_init_dict()
# initval_block = []
# initval_block.append("initval;")
# for v in self.model.variables:
# if v in self.init_values:
# initval_block.append(str(v) + " = " + str(itd[v]) + ";")
# initval_block.append("end;")
model_text = ""
model_text += "\n".join(init_block)
model_text += "\n\n" + "\n".join(model_block)
model_text += "\n\n" + "\n".join(shocks_block)
model_text += "\n\n" + "\n".join(initval_block)
if options["steady"] and options["dest"] == "dynare":
model_text += "\n\nsteady;\n"
if options["check"] and options["dest"] == "dynare":
model_text += "\n\ncheck;\n"
if options["dest"] == "dynare++":
model_text += "\n\norder = " + str(options["order"]) + ";\n"
model_text += "\n" + append
if output_file == None:
output_file = self.model.fname + ".mod"
if output_file != False:
f = file(output_file, "w")
f.write(model_text)
f.close()
if return_text:
return model_text
else:
return None
def compute_main_file(self, omit_nnz=True):
model = self.model
# should be computed somewhere else
all_symbols = set([])
for eq in model.equations:
all_symbols.update(eq.atoms())
format_dict = dict()
format_dict["fname"] = model.fname
format_dict["maximum_lag"] = max([-v.lag for v in all_symbols if isinstance(v, TSymbol)])
format_dict["maximum_lead"] = max([v.lag for v in all_symbols if isinstance(v, TSymbol)])
format_dict["maximum_endo_lag"] = max([-v.lag for v in all_symbols if isinstance(v, Variable)])
format_dict["maximum_endo_lead"] = max([v.lag for v in all_symbols if isinstance(v, Variable)])
format_dict["maximum_exo_lag"] = max([-v.lag for v in all_symbols if isinstance(v, Shock)])
format_dict["maximum_exo_lead"] = max([v.lag for v in all_symbols if isinstance(v, Shock)])
format_dict["endo_nbr"] = len(model.variables)
format_dict["exo_nbr"] = len(model.shocks)
format_dict["param_nbr"] = len(model.parameters)
output = """%
% Status : main Dynare file
%
% Warning : this file is generated automatically by Dolo for Dynare
% from model file (.mod)
clear all
tic;
global M_ oo_ options_
global ys0_ ex0_ ct_
options_ = [];
M_.fname = '{fname}';
%
% Some global variables initialization
%
global_initialization;
diary off;
warning_old_state = warning;
warning off;
delete {fname}.log;
warning warning_old_state;
logname_ = '{fname}.log';
diary {fname}.log;
options_.model_mode = 0;
erase_compiled_function('{fname}_static');
erase_compiled_function('{fname}_dynamic');
M_.exo_det_nbr = 0;
M_.exo_nbr = {exo_nbr};
M_.endo_nbr = {endo_nbr};
M_.param_nbr = {param_nbr};
M_.Sigma_e = zeros({exo_nbr}, {exo_nbr});
M_.exo_names_orig_ord = [1:{exo_nbr}];
""".format(
**format_dict
)
string_of_names = lambda l: str.join(" , ", ["'%s'" % str(v) for v in l])
string_of_tex_names = lambda l: str.join(" , ", ["'%s'" % v._latex_() for v in l])
output += "M_.exo_names = strvcat( {0} );\n".format(string_of_names(model.shocks))
output += "M_.exo_names_tex = strvcat( {0} );\n".format(string_of_tex_names(model.shocks))
output += "M_.endo_names = strvcat( {0} );\n".format(string_of_names(model.variables))
output += "M_.endo_names_tex = strvcat( {0} );\n".format(string_of_tex_names(model.variables))
output += "M_.param_names = strvcat( {0} );\n".format(string_of_names(model.parameters))
output += "M_.param_names_tex = strvcat( {0} );\n".format(string_of_tex_names(model.parameters))
from dolo.misc.matlab import value_to_mat
lli = value_to_mat(self.lead_lag_incidence_matrix())
output += "M_.lead_lag_incidence = {0}';\n".format(lli)
output += """M_.maximum_lag = {maximum_lag};
M_.maximum_lead = {maximum_lead};
M_.maximum_endo_lag = {maximum_endo_lag};
M_.maximum_endo_lead = {maximum_endo_lead};
M_.maximum_exo_lag = {maximum_exo_lag};
M_.maximum_exo_lead = {maximum_exo_lead};
oo_.steady_state = zeros({endo_nbr}, 1);
oo_.exo_steady_state = zeros({exo_nbr}, 1);
M_.params = repmat(NaN,{param_nbr}, 1);
""".format(
**format_dict
)
# Now we add tags for equations
tags_array_string = []
for eq in model.equations:
for k in eq.tags.keys():
tags_array_string.append("{n}, '{key}', '{value}'".format(n=eq.n, key=k, value=eq.tags[k]))
output += "M_.equations_tags = {{\n{0}\n}};\n".format(";\n".join(tags_array_string))
if not omit_nnz:
# we don't set the number of non zero derivatives yet
order = max([ndt.depth() for ndt in self.dynamic_derivatives])
output += "M_.NNZDerivatives = zeros({0}, 1); % parrot mode\n".format(order)
output += "M_.NNZDerivatives(1) = {0}; % parrot mode\n".format(self.NNZDerivatives(1))
output += "M_.NNZDerivatives(2) = {0}; % parrot mode\n".format(self.NNZDerivatives(2))
output += "M_.NNZDerivatives(3) = {0}; % parrot mode\n".format(self.NNZDerivatives(3))
idp = DicPrinter(self.static_substitution_list(y="oo_.steady_state", params="M_.params"))
# BUG: how do we treat parameters absent from the model, but present in parameters_values ?
from dolo.misc.triangular_solver import solve_triangular_system
[junk, porder] = solve_triangular_system(model.parameters_values)
porder = [p for p in porder if p in model.parameters]
d = dict()
d.update(model.parameters_values)
d.update(model.init_values)
[junk, vorder] = solve_triangular_system(model.init_values)
vorder = [v for v in vorder if p in model.variables]
for p in porder:
i = model.parameters.index(p) + 1
output += "M_.params({0}) = {1};\n".format(i, idp.doprint_matlab(model.parameters_values[p]))
output += "{0} = M_.params({1});\n".format(p, i)
output += """%
% INITVAL instructions
%
"""
# idp = DicPrinter(self.static_substitution_list(y='oo_.steady_state',params='M_.params'))
output += "options_.initval_file = 0; % parrot mode\n"
for v in vorder:
if v in self.model.variables: # should be removed
i = model.variables.index(v) + 1
output += "oo_.steady_state({0}) = {1};\n".format(i, idp.doprint_matlab(model.init_values[v]))
# we don't allow initialization of shocks to nonzero values
output += "oo_.exo_steady_state = zeros({0},1);\n".format(len(model.shocks))
output += """oo_.endo_simul=[oo_.steady_state*ones(1,M_.maximum_lag)];
if M_.exo_nbr > 0;
oo_.exo_simul = [ones(M_.maximum_lag,1)*oo_.exo_steady_state'];
end;
if M_.exo_det_nbr > 0;
oo_.exo_det_simul = [ones(M_.maximum_lag,1)*oo_.exo_det_steady_state'];
end;
"""
# output += '''steady;
output += """
%
% SHOCKS instructions
%
make_ex_;
M_.exo_det_length = 0; % parrot
"""
for i in range(model.covariances.shape[0]):
for j in range(model.covariances.shape[1]):
expr = model.covariances[i, j]
if expr != 0:
v = str(expr).replace("**", "^")
# if (v != 0) and not isinstance(v,sympy.core.numbers.Zero):
output += "M_.Sigma_e({0}, {1}) = {2};\n".format(i + 1, j + 1, v)
# This results from the stoch_simul(
# output += '''options_.drop = 200;
# options_.order = 3;
# var_list_=[];
# info = stoch_simul(var_list_);
#'''
#
# output += '''save('example2_results.mat', 'oo_', 'M_', 'options_');
# diary off
#
# disp(['Total computing time : ' dynsec2hms(toc) ]);'''
f = file(model.fname + ".m", "w")
f.write(output)
f.close()
return output
def compute_main_file(self, omit_nnz=True):
model = self.model
# should be computed somewhere else
all_symbols = set([])
for eq in model.equations:
all_symbols.update(eq.atoms())
format_dict = dict()
format_dict['fname'] = model.fname
format_dict['maximum_lag'] = max(
[-v.lag for v in all_symbols if isinstance(v, TSymbol)])
format_dict['maximum_lead'] = max(
[v.lag for v in all_symbols if isinstance(v, TSymbol)])
format_dict['maximum_endo_lag'] = max(
[-v.lag for v in all_symbols if isinstance(v, Variable)])
format_dict['maximum_endo_lead'] = max(
[v.lag for v in all_symbols if isinstance(v, Variable)])
format_dict['maximum_exo_lag'] = max(
[-v.lag for v in all_symbols if isinstance(v, Shock)])
format_dict['maximum_exo_lead'] = max(
[v.lag for v in all_symbols if isinstance(v, Shock)])
format_dict['endo_nbr'] = len(model.variables)
format_dict['exo_nbr'] = len(model.shocks)
format_dict['param_nbr'] = len(model.parameters)
output = """%
% Status : main Dynare file
%
% Warning : this file is generated automatically by Dolo for Dynare
% from model file (.mod)
clear all
tic;
global M_ oo_ options_
global ys0_ ex0_ ct_
options_ = [];
M_.fname = '{fname}';
%
% Some global variables initialization
%
global_initialization;
diary off;
warning_old_state = warning;
warning off;
delete {fname}.log;
warning warning_old_state;
logname_ = '{fname}.log';
diary {fname}.log;
options_.model_mode = 0;
erase_compiled_function('{fname}_static');
erase_compiled_function('{fname}_dynamic');
M_.exo_det_nbr = 0;
M_.exo_nbr = {exo_nbr};
M_.endo_nbr = {endo_nbr};
M_.param_nbr = {param_nbr};
M_.Sigma_e = zeros({exo_nbr}, {exo_nbr});
M_.exo_names_orig_ord = [1:{exo_nbr}];
""".format(**format_dict)
string_of_names = lambda l: str.join(' , ',
["'%s'" % str(v) for v in l])
string_of_tex_names = lambda l: str.join(
' , ', ["'%s'" % v._latex_() for v in l])
output += "M_.exo_names = strvcat( {0} );\n".format(
string_of_names(model.shocks))
output += "M_.exo_names_tex = strvcat( {0} );\n".format(
string_of_tex_names(model.shocks))
output += "M_.endo_names = strvcat( {0} );\n".format(
string_of_names(model.variables))
output += "M_.endo_names_tex = strvcat( {0} );\n".format(
string_of_tex_names(model.variables))
output += "M_.param_names = strvcat( {0} );\n".format(
string_of_names(model.parameters))
output += "M_.param_names_tex = strvcat( {0} );\n".format(
string_of_tex_names(model.parameters))
from dolo.misc.matlab import value_to_mat
lli = value_to_mat(self.lead_lag_incidence_matrix())
output += "M_.lead_lag_incidence = {0}';\n".format(lli)
output += """M_.maximum_lag = {maximum_lag};
M_.maximum_lead = {maximum_lead};
M_.maximum_endo_lag = {maximum_endo_lag};
M_.maximum_endo_lead = {maximum_endo_lead};
M_.maximum_exo_lag = {maximum_exo_lag};
M_.maximum_exo_lead = {maximum_exo_lead};
oo_.steady_state = zeros({endo_nbr}, 1);
oo_.exo_steady_state = zeros({exo_nbr}, 1);
M_.params = repmat(NaN,{param_nbr}, 1);
""".format(**format_dict)
# Now we add tags for equations
tags_array_string = []
for eq in model.equations:
for k in eq.tags.keys():
tags_array_string.append("{n}, '{key}', '{value}'".format(
n=eq.n, key=k, value=eq.tags[k]))
output += "M_.equations_tags = {{\n{0}\n}};\n".format(
";\n".join(tags_array_string))
if not omit_nnz:
# we don't set the number of non zero derivatives yet
order = max([ndt.depth() for ndt in self.dynamic_derivatives])
output += "M_.NNZDerivatives = zeros({0}, 1); % parrot mode\n".format(
order)
output += "M_.NNZDerivatives(1) = {0}; % parrot mode\n".format(
self.NNZDerivatives(1))
output += "M_.NNZDerivatives(2) = {0}; % parrot mode\n".format(
self.NNZDerivatives(2))
output += "M_.NNZDerivatives(3) = {0}; % parrot mode\n".format(
self.NNZDerivatives(3))
idp = DicPrinter(
self.static_substitution_list(y='oo_.steady_state',
params='M_.params'))
# BUG: how do we treat parameters absent from the model, but present in parameters_values ?
from dolo.misc.triangular_solver import solve_triangular_system
[junk, porder] = solve_triangular_system(model.parameters_values)
porder = [p for p in porder if p in model.parameters]
d = dict()
d.update(model.parameters_values)
d.update(model.init_values)
[junk, vorder] = solve_triangular_system(model.init_values)
vorder = [v for v in vorder if p in model.variables]
for p in porder:
i = model.parameters.index(p) + 1
output += "M_.params({0}) = {1};\n".format(
i, idp.doprint_matlab(model.parameters_values[p]))
output += "{0} = M_.params({1});\n".format(p, i)
output += '''%
% INITVAL instructions
%
'''
#idp = DicPrinter(self.static_substitution_list(y='oo_.steady_state',params='M_.params'))
output += "options_.initval_file = 0; % parrot mode\n"
for v in vorder:
if v in self.model.variables: # should be removed
i = model.variables.index(v) + 1
output += "oo_.steady_state({0}) = {1};\n".format(
i, idp.doprint_matlab(model.init_values[v]))
# we don't allow initialization of shocks to nonzero values
output += "oo_.exo_steady_state = zeros({0},1);\n".format(
len(model.shocks))
output += '''oo_.endo_simul=[oo_.steady_state*ones(1,M_.maximum_lag)];
if M_.exo_nbr > 0;
oo_.exo_simul = [ones(M_.maximum_lag,1)*oo_.exo_steady_state'];
end;
if M_.exo_det_nbr > 0;
oo_.exo_det_simul = [ones(M_.maximum_lag,1)*oo_.exo_det_steady_state'];
end;
'''
#output += '''steady;
output += """
%
% SHOCKS instructions
%
make_ex_;
M_.exo_det_length = 0; % parrot
"""
for i in range(model.covariances.shape[0]):
for j in range(model.covariances.shape[1]):
expr = model.covariances[i, j]
if expr != 0:
v = str(expr).replace("**", "^")
#if (v != 0) and not isinstance(v,sympy.core.numbers.Zero):
output += "M_.Sigma_e({0}, {1}) = {2};\n".format(
i + 1, j + 1, v)
# This results from the stoch_simul(
# output += '''options_.drop = 200;
#options_.order = 3;
#var_list_=[];
#info = stoch_simul(var_list_);
#'''
#
# output += '''save('example2_results.mat', 'oo_', 'M_', 'options_');
#diary off
#
#disp(['Total computing time : ' dynsec2hms(toc) ]);'''
f = file(model.fname + '.m', 'w')
f.write(output)
f.close()
return output
def export_to_modfile(self,
output_file=None,
return_text=False,
options={},
append="",
comments="",
solve_init_state=False):
model = self.model
#init_state = self.get_init_dict()
default = {
'steady': False,
'check': False,
'dest': 'dynare',
'order': 1,
'use_dll': False
} #default options
for o in default:
if not o in options:
options[o] = default[o]
init_block = ["// Generated by Dolo"]
init_block.append("// Model basename : " + self.model.fname)
init_block.append(comments)
init_block.append("")
init_block.append("var " +
str.join(",", map(str, self.model.variables)) + ";")
init_block.append("")
init_block.append("varexo " +
str.join(",", map(str, self.model.shocks)) + ";")
init_block.append("")
init_block.append("parameters " +
str.join(",", map(str, self.model.parameters)) + ";")
init_state = model.parameters_values.copy()
init_state.update(model.init_values.copy())
from dolo.misc.triangular_solver import solve_triangular_system
if not solve_init_state:
itd = model.init_values
order = solve_triangular_system(init_state, return_order=True)
else:
itd, order = solve_triangular_system(init_state)
for p in order:
if p in model.parameters:
#init_block.append(p.name + " = " + str(init_state[p]) + ";")
if p in model.parameters_values:
init_block.append(
p.name + " = " +
str(model.parameters_values[p]).replace('**', '^') +
";")
printer = CustomPrinter()
model_block = []
if options['use_dll']:
model_block.append("model(use_dll);")
else:
model_block.append("model;")
for eq in self.model.equations:
s = printer.doprint(eq)
s = s.replace("==", "=")
s = s.replace("**", "^")
# s = s.replace("_b1","(-1)") # this should allow lags more than 1
# s = s.replace("_f1","(+1)") # this should allow lags more than 1
model_block += "\n"
if 'name' in eq.tags:
model_block.append("// eq %s : %s" %
(eq.n, eq.tags.get('name')))
else:
model_block.append("// eq %s" % (eq.n))
if len(eq.tags) > 0:
model_block.append("[ {0} ]".format(" , ".join(
["{0} = '{1}'".format(k, eq.tags[k]) for k in eq.tags])))
model_block.append(s + ";")
model_block.append("end;")
if options['dest'] == 'dynare':
shocks_block = []
if model.covariances != None:
shocks_block.append("shocks;")
cov_shape = model.covariances.shape
for i in range(cov_shape[0]):
for j in range(i, cov_shape[1]):
cov = model.covariances[i, j]
if cov != 0:
tcov = str(cov).replace('**', '^')
if i == j:
shocks_block.append("var " +
str(self.model.shocks[i]) +
" = " + tcov + " ;")
else:
shocks_block.append("var " +
str(self.model.shocks[i]) +
"," +
str(self.model.shocks[j]) +
" = " + tcov + " ;")
shocks_block.append("end;")
elif options['dest'] == 'dynare++':
shocks_block = []
shocks_block.append("vcov = [")
cov_shape = self.covariances.shape
shocks_matrix = []
for i in range(cov_shape[0]):
shocks_matrix.append(" ".join(map(str,
self.covariances[i, :])))
shocks_block.append(";\n".join(shocks_matrix))
shocks_block.append("];")
initval_block = []
if len(model.init_values) > 0:
initval_block.append("initval;")
for v in order:
if v in model.init_values:
initval_block.append(
str(v) + " = " + str(itd[v]).replace('**', '^') + ";")
elif options['dest'] == 'dynare++':
# dynare++ doesn't default to zero for non initialized variables
initval_block.append(str(v) + " = 0 ;")
initval_block.append("end;")
#else:
#itd = self.get_init_dict()
#initval_block = []
#initval_block.append("initval;")
#for v in self.model.variables:
#if v in self.init_values:
#initval_block.append(str(v) + " = " + str(itd[v]) + ";")
#initval_block.append("end;")
model_text = ""
model_text += "\n".join(init_block)
model_text += "\n\n" + "\n".join(model_block)
model_text += "\n\n" + "\n".join(shocks_block)
model_text += "\n\n" + "\n".join(initval_block)
if options['steady'] and options['dest'] == 'dynare':
model_text += "\n\nsteady;\n"
if options['check'] and options['dest'] == 'dynare':
model_text += "\n\ncheck;\n"
if options['dest'] == 'dynare++':
model_text += "\n\norder = " + str(options['order']) + ";\n"
model_text += "\n" + append
if output_file == None:
output_file = self.model.fname + '.mod'
if output_file != False:
f = file(output_file, 'w')
f.write(model_text)
f.close()
if return_text:
return (model_text)
else:
return None
def simple_global_representation(self, allow_future_shocks=True, solve_systems=False):
resp = {}
eq_g = self['equations_groups']
v_g = self['variables_groups']
if 'expectation' in eq_g:
resp['f_eqs'] = [ eq.gap for eq in eq_g['arbitrage'] + eq_g['expectation']] # TODO: complementarity conditions
resp['controls'] = v_g['controls'] + v_g['expectations']
else:
resp['f_eqs'] = [ eq.gap for eq in eq_g['arbitrage']] # TODO: complementarity conditions
resp['controls'] = list( v_g['controls'] )
resp['g_eqs'] = [eq.rhs for eq in eq_g['transition'] ]
if 'auxiliary' in eq_g:
sdict = {}
from dolo.symbolic.symbolic import timeshift
auxies = list( eq_g['auxiliary'] )
if 'auxiliary_2' in eq_g:
auxies += list( eq_g['auxiliary_2'] )
for eq in auxies:
sdict[eq.lhs] = eq.rhs
sdict[eq.lhs(1)] = timeshift( eq.rhs, 1)
sdict[eq.lhs(-1)] = timeshift( eq.rhs, -1)
from dolo.misc.triangular_solver import solve_triangular_system
sdict = solve_triangular_system(sdict)
resp['a_eqs'] = [sdict[v] for v in v_g['auxiliary']]
resp['auxiliaries'] = [v for v in v_g['auxiliary']]
resp['f_eqs'] = [eq.subs(sdict) for eq in resp['f_eqs']]
resp['g_eqs'] = [eq.subs(sdict) for eq in resp['g_eqs']]
elif 'auxiliary_2' in eq_g:
sdict = {}
from dolo.misc.misc import timeshift
auxies = eq_g['auxiliary_2']
for eq in auxies:
sdict[eq.lhs] = eq.rhs
sdict[eq.lhs(1)] = timeshift( eq.rhs, 1)
sdict[eq.lhs(-1)] = timeshift( eq.rhs, -1)
from dolo.misc.calculus import simple_triangular_solve
sdict = simple_triangular_solve(sdict)
resp['f_eqs'] = [eq.subs(sdict) for eq in resp['f_eqs']]
resp['g_eqs'] = [eq.subs(sdict) for eq in resp['g_eqs']]
if not allow_future_shocks:
# future shocks are replaced by 0
zero_shocks = {s(1):0 for s in self.shocks}
resp['f_eqs'] = [ eq.subs(zero_shocks) for eq in resp['f_eqs'] ]
if solve_systems:
from dolo.misc.triangular_solver import solve_triangular_system
system = {s: resp['g_eqs'][i] for i,s in enumerate(v_g['states'])}
new_geqs = solve_triangular_system(system)
resp['g_eqs'] = [new_geqs[s] for s in v_g['states']]
resp['states'] = v_g['states']
resp['shocks'] = self.shocks #['shocks_ordering'] # TODO: bad
resp['parameters'] = self.parameters #['parameters_ordering']
return resp
]
from sympy import exp
eqs = [
x + y*k_2 + z*exp(x_1 + t),
(y + z)**0.3,
z,
(k_1 + k_2)**0.3,
k_2**x_1
]
sdict = {s:eqs[i] for i,s in enumerate(vars) }
from dolo.misc.triangular_solver import solve_triangular_system
order = solve_triangular_system(sdict, return_order=True)
ordered_vars = [ v for v in order ]
ordered_eqs = [ eqs[vars.index(v)] for v in order ]
pprint(ordered_vars)
pprint(ordered_eqs)
# f = create_fun()
#
# test = f(s1,x1,p0)
# print(test)
args_names = ['s','x']
#
