def compile_incidence_matrices(equations, args_list):
'''Calculate the incidence matrices of a system of equations with respect to several sets of variables and convert it to MATLAB cell array'''
from dolo.misc.matlab import value_to_mat
text = '''{'''
for i,a_g in enumerate(args_list):
text += value_to_mat(JacobianStructure(equations,a_g)).replace('[[','[').replace(']]',']') + ' '
text += '};'
return text
def export_infos(self):
from dolo.misc.matlab import struct_to_mat, value_to_mat
model = self.model
txt = 'global infos_;\n'
txt += struct_to_mat(model.info,'infos_')
# we compute the list of portfolio equations
def select(x):
if x.tags.get('portfolio','false') == 'true':
return '1'
else:
return '0'
txt += 'infos_.portfolio_equations = [%s];\n' % str.join(' ',[select(x) for x in model.equations])
incidence_matrix = model.incidence_matrix_static()
txt += 'infos_.incidence_matrix_static = %s;\n' % value_to_mat(incidence_matrix)
f = file(model.fname + '_infos.m','w')
f.write(txt)
f.close()
def export_infos(self):
from dolo.misc.matlab import struct_to_mat, value_to_mat
model = self.model
txt = "global infos_;\n"
txt += struct_to_mat(model.info, "infos_")
# we compute the list of portfolio equations
def select(x):
if x.tags.get("portfolio", "false") == "true":
return "1"
else:
return "0"
txt += "infos_.portfolio_equations = [%s];\n" % str.join(" ", [select(x) for x in model.equations])
incidence_matrix = model.incidence_matrix_static()
txt += "infos_.incidence_matrix_static = %s;\n" % value_to_mat(incidence_matrix)
f = file(model.fname + "_infos.m", "w")
f.write(txt)
f.close()
def export_infos(self):
from dolo.misc.matlab import struct_to_mat, value_to_mat
model = self.model
txt = 'global infos_;\n'
txt += struct_to_mat(model.info, 'infos_')
# we compute the list of portfolio equations
def select(x):
if x.tags.get('portfolio', 'false') == 'true':
return '1'
else:
return '0'
txt += 'infos_.portfolio_equations = [%s];\n' % str.join(
' ', [select(x) for x in model.equations])
incidence_matrix = model.incidence_matrix_static()
txt += 'infos_.incidence_matrix_static = %s;\n' % value_to_mat(
incidence_matrix)
f = file(model.fname + '_infos.m', 'w')
f.write(txt)
f.close()
def process_output(self, solution_order=False, fname=None):
from dolo.numeric.perturbations_to_states import simple_global_representation
data = simple_global_representation(self.model,
substitute_auxiliary=True,
keep_auxiliary=True,
solve_systems=True)
# print data['a_eqs']
# print data['f_eqs']
dmodel = self.model
model = dmodel
f_eqs = data['f_eqs']
g_eqs = data['g_eqs']
g_eqs = [
map_function_to_expression(lambda x: timeshift(x, 1), eq)
for eq in g_eqs
]
# h_eqs = data['h_eqs']
auxiliaries = data['auxiliaries']
states = data['states']
controls = data['controls']
# exp_vars = data['exp_vars']
#inf_bounds = data['inf_bounds']
#sup_bounds = data['sup_bounds']
controls_f = [v(1) for v in controls]
states_f = [v(1) for v in states]
sub_list = dict()
# for i,v in enumerate(exp_vars):
# sub_list[v] = 'z(:,{0})'.format(i+1)
for i, v in enumerate(controls):
sub_list[v] = 'x(:,{0})'.format(i + 1)
sub_list[v(1)] = 'xnext(:,{0})'.format(i + 1)
for i, v in enumerate(states):
sub_list[v] = 's(:,{0})'.format(i + 1)
sub_list[v(1)] = 'snext(:,{0})'.format(i + 1)
for i, v in enumerate(dmodel.shocks):
sub_list[v] = 'e(:,{0})'.format(i + 1)
for i, v in enumerate(dmodel.parameters):
sub_list[v] = 'p({0})'.format(i + 1)
text = '''function [model] = get_model()
model = model_info;
model.f = @f;
model.g = @g;
model.a = @a;
end
function [out1,out2,out3,out4,out5] = f(s,x,snext,xnext,p)
n = size(s,1);
{eq_fun_block}
end
function [out1,out2,out3] = g(s,x,e,p)
n = size(s,1);
{state_trans_block}
end
function [out1,out2,out3] = a(s,x,p)
n = size(s,1);
{aux_block}
end
function [out1] = model_info() % informations about the model
{model_info}
end
'''
from dolo.compiler.compiler import DicPrinter
dp = DicPrinter(sub_list)
def write_eqs(eq_l, outname='out1', ntabs=0):
eq_block = ' ' * ntabs + '{0} = zeros(n,{1});'.format(
outname, len(eq_l))
for i, eq in enumerate(eq_l):
eq_block += '\n' + ' ' * ntabs + '{0}(:,{1}) = {2};'.format(
outname, i + 1, dp.doprint_matlab(eq, vectorize=True))
return eq_block
def write_der_eqs(eq_l, v_l, lhs, ntabs=0):
eq_block = ' ' * ntabs + '{lhs} = zeros(n,{0},{1});'.format(
len(eq_l), len(v_l), lhs=lhs)
eq_l_d = eqdiff(eq_l, v_l)
for i, eqq in enumerate(eq_l_d):
for j, eq in enumerate(eqq):
s = dp.doprint_matlab(eq, vectorize=True)
eq_block += '\n' + ' ' * ntabs + '{lhs}(:,{0},{1}) = {2}; % d eq_{eq_n} w.r.t. {vname}'.format(
i + 1,
j + 1,
s,
lhs=lhs,
eq_n=i + 1,
vname=str(v_l[j]))
return eq_block
# eq_bounds_block = write_eqs(inf_bounds,ntabs=2)
# eq_bounds_block += '\n'
# eq_bounds_block += write_eqs(sup_bounds,'out2',ntabs=2)
eq_f_block = '''
% f
{0}
if nargout >= 2
% df/ds
{1}
% df/dx
{2}
% df/dsnext
{3}
% df/dxnext
{4}
end
'''.format(
write_eqs(f_eqs, 'out1', 3),
write_der_eqs(f_eqs, states, 'out2', 3),
write_der_eqs(f_eqs, controls, 'out3', 3),
write_der_eqs(f_eqs, states_f, 'out4', 3),
write_der_eqs(f_eqs, controls_f, 'out5', 3),
# write_der_eqs(f_eqs,exp_vars,'out4',3)
)
eq_g_block = '''
% g
{0}
if nargout >=2
% dg/ds
{1}
% dg/dx
{2}
end
'''.format(write_eqs(g_eqs, 'out1', 3),
write_der_eqs(g_eqs, states, 'out2', 3),
write_der_eqs(g_eqs, controls, 'out3', 3))
if 'a_eqs' in data:
a_eqs = data['a_eqs']
eq_a_block = '''
% a
{0}
if nargout >=2
% da/ds
{1}
% da/dx
{2}
end
'''.format(write_eqs(a_eqs, 'out1', 3),
write_der_eqs(a_eqs, states, 'out2', 3),
write_der_eqs(a_eqs, controls, 'out3', 3))
else:
eq_a_block = ''
# if not with_param_names:
# eq_h_block = 's=snext;\nx=xnext;\n'+eq_h_block
# param_def = 'p = [ ' + str.join(',',[p.name for p in dmodel.parameters]) + '];'
from dolo.misc.matlab import value_to_mat
# read model informations
[y, x, params_values] = model.read_calibration()
#params_values = '[' + str.join( ',', [ str( p ) for p in params] ) + '];'
vvs = model.variables
s_ss = [y[vvs.index(v)] for v in model['variables_groups']['states']]
x_ss = [y[vvs.index(v)] for v in model['variables_groups']['controls']]
model_info = '''
mod = struct;
mod.states = {states};
mod.controls = {controls};
mod.auxiliaries = {auxiliaries};
mod.parameters = {parameters};
mod.shocks = {shocks};
mod.s_ss = {s_ss};
mod.x_ss = {x_ss};
mod.params = {params_values};
'''.format(states='{{ {} }}'.format(
str.join(',', ["'{}'".format(v) for v in states])),
controls='{{ {} }}'.format(
str.join(',', ["'{}'".format(v) for v in controls])),
auxiliaries='{{ {} }}'.format(
str.join(',', ["'{}'".format(v) for v in auxiliaries])),
parameters='{{ {} }}'.format(
str.join(',', ["'{}'".format(v) for v in model.parameters])),
shocks='{{ {} }}'.format(
str.join(',', ["'{}'".format(v) for v in model.shocks])),
s_ss=value_to_mat(s_ss),
x_ss=value_to_mat(x_ss),
params_values=value_to_mat(params_values))
if solution_order:
from dolo.numeric.perturbations_to_states import approximate_controls
ZZ = approximate_controls(self.model,
order=solution_order,
return_dr=False)
n_c = len(controls)
ZZ = [np.array(e) for e in ZZ]
ZZ = [e[:n_c, ...] for e in ZZ
] # keep only control vars. (x) not expectations (h)
solution = " mod.X = cell({0},1);\n".format(len(ZZ))
for i, zz in enumerate(ZZ):
solution += " mod.X{{{0}}} = {1};\n".format(
i + 1, value_to_mat(zz.real))
model_info += solution
model_info += ' out1 = mod;\n'
text = text.format(
# eq_bounds_block = eq_bounds_block,
mfname=fname if fname else 'mf_' + model.fname,
eq_fun_block=eq_f_block,
state_trans_block=eq_g_block,
aux_block=eq_a_block,
# exp_fun_block=eq_h_block,
# solution = solution,
model_info=model_info)
return text
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.calculus 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 process_output_recs(self):
'''Main function that formats the model in recs format'''
import sympy
from dolo.compiler.common import DicPrinter
from dolo.misc.matlab import value_to_mat
data = self.read_model()
dmodel = self.model
model = dmodel
f_eqs = data['f_eqs']
g_eqs = data['g_eqs']
h_eqs = data['h_eqs']
hm_eqs = data['hm_eqs']
e_eqs = data['e_eqs']
states_vars = data['states_vars']
controls = data['controls']
exp_vars = data['exp_vars']
inf_bounds = data['inf_bounds']
sup_bounds = data['sup_bounds']
controls_f = [v(1) for v in controls]
states_f = [v(1) for v in states_vars]
sub_list = dict()
for i,v in enumerate(exp_vars):
sub_list[v] = 'z(:,{0})'.format(i+1)
for i,v in enumerate(controls):
sub_list[v] = 'x(:,{0})'.format(i+1)
sub_list[v(1)] = 'xnext(:,{0})'.format(i+1)
for i,v in enumerate(states_vars):
sub_list[v] = 's(:,{0})'.format(i+1)
sub_list[v(1)] = 'snext(:,{0})'.format(i+1)
for i,v in enumerate(dmodel.shocks):
sub_list[v] = 'e(:,{0})'.format(i+1)
for i,v in enumerate(dmodel.parameters):
sub_list[v] = 'p({0})'.format(i+1)
sub_list[sympy.Symbol('inf')] = 'inf'
# Case h(s,x,e,sn,xn)
text = '''function [out1,out2,out3,out4,out5] = {filename}(flag,s,x,z,e,snext,xnext,p,output)
voidcell = cell(1,5);
[out1,out2,out3,out4,out5] = voidcell{{:}};
switch flag
case 'b'
n = size(s,1);
{eq_bounds_block}
case 'f'
n = size(s,1);
{eq_fun_block}
case 'g'
n = size(s,1);
{state_trans_block}
case 'h'
n = size(snext,1);
{exp_fun_block}
case 'e'
n = size(s,1);
{equation_error_block}
case 'params'
out1 = {model_params};
case 'ss'
{model_ss}
case 'J'
{jac_struc}
end'''
# Case h(.,.,.,sn,xn)*hmult(e)
textmult = '''function [out1,out2,out3,out4,out5,out6] = {filename}(flag,s,x,z,e,snext,xnext,p,output)
voidcell = cell(1,6);
[out1,out2,out3,out4,out5,out6] = voidcell{{:}};
switch flag
case 'b'
n = size(s,1);
{eq_bounds_block}
case 'f'
n = size(s,1);
{eq_fun_block}
case 'g'
n = size(s,1);
{state_trans_block}
case 'h'
n = size(snext,1);
{exp_fun_block}
{exp_exp_mult_block}
case 'e'
n = size(s,1);
{equation_error_block}
case 'params'
out1 = {model_params};
case 'ss'
{model_ss}
case 'J'
{jac_struc}
end'''
dp = DicPrinter(sub_list)
def write_eqs(eq_l, outname='out1', ntabs=0, default=None):
'''Format equations and bounds'''
if default:
eq_block = ' ' * ntabs + '{0} = ' + default + '(n,{1});'
eq_block = eq_block.format(outname,len(eq_l))
else:
eq_block = ' ' * ntabs + '{0} = zeros(n,{1});'.format(outname,len(eq_l))
eq_template = '\n' + ' ' * ntabs + '{0}(:,{1}) = {2};'
for i,eq in enumerate(eq_l):
eq_txt = dp.doprint_matlab(eq,vectorize=True)
if eq_txt != default:
eq_block += eq_template.format(outname, i+1, eq_txt)
return eq_block
def write_der_eqs(eq_l, v_l, lhs, ntabs=0):
'''Format Jacobians'''
eq_block = ' ' * ntabs + '{lhs} = zeros(n,{0},{1});'
eq_block = eq_block.format(len(eq_l), len(v_l), lhs=lhs)
eq_l_d = eqdiff(eq_l,v_l)
eq_template = '\n' + ' ' * ntabs + '{lhs}(:,{0},{1}) = {2}; % d eq_{eq_n} w.r.t. {vname}'
jac_struc = [[0 for i in range(len(v_l))] for j in range(len(eq_l))]
for i,eqq in enumerate(eq_l_d):
for j,eq in enumerate(eqq):
s = dp.doprint_matlab(eq, vectorize=True)
if s != '0':
eq_block += eq_template.format(i+1, j+1, s, lhs=lhs, eq_n=i+1, vname=str(v_l[j]))
jac_struc[i][j] = 1
return [eq_block,jac_struc]
eq_bounds_block = '''
% b
{0}
% db/ds
if nargout==4
{1}
{2}
end'''
eq_bounds_values = write_eqs(inf_bounds, ntabs=2, default='-inf')
eq_bounds_values += '\n'
eq_bounds_values += write_eqs(sup_bounds, 'out2', ntabs=2, default='inf')
eq_bounds_jac_inf = write_der_eqs(inf_bounds, states_vars, 'out3', 3)
eq_bounds_jac_sup = write_der_eqs(sup_bounds, states_vars, 'out4', 3)
eq_bounds_block = eq_bounds_block.format(eq_bounds_values,
eq_bounds_jac_inf[0],
eq_bounds_jac_sup[0])
eq_f_block = '''
% f
if output.F
{0}
end
% df/ds
if output.Js
{1}
end
% df/dx
if output.Jx
{2}
end
% df/dz
if output.Jz
{3}
end'''
# eq_f_block = eq_f_block.format(write_eqs(f_eqs, 'out1', 3),
# write_der_eqs(f_eqs, states_vars, 'out2', 3),
# write_der_eqs(f_eqs, controls, 'out3', 3),
# write_der_eqs(f_eqs, exp_vars, 'out4', 3))
df_ds = write_der_eqs(f_eqs, states_vars, 'out2', 3)
df_dx = write_der_eqs(f_eqs, controls, 'out3', 3)
df_dz = write_der_eqs(f_eqs, exp_vars, 'out4', 3)
eq_f_block = eq_f_block.format(write_eqs(f_eqs, 'out1', 3),
df_ds[0],
df_dx[0],
df_dz[0])
jac_struc = ' out1.fs = '+list_to_mat(df_ds[1])+';\n'
jac_struc += ' out1.fx = '+list_to_mat(df_dx[1])+';\n'
jac_struc += ' out1.fz = '+list_to_mat(df_dz[1])+';\n'
eq_g_block = '''
% g
if output.F
{0}
end
if output.Js
{1}
end
if output.Jx
{2}
end'''
# eq_g_block = eq_g_block.format(write_eqs(g_eqs, 'out1', 3),
# write_der_eqs(g_eqs, states_vars, 'out2', 3),
# write_der_eqs(g_eqs, controls, 'out3', 3))
dg_ds = write_der_eqs(g_eqs, states_vars, 'out2', 3)
dg_dx = write_der_eqs(g_eqs, controls, 'out3', 3)
eq_g_block = eq_g_block.format(write_eqs(g_eqs, 'out1', 3),
dg_ds[0],
dg_dx[0])
jac_struc += ' out1.gs = '+list_to_mat(dg_ds[1])+';\n'
jac_struc += ' out1.gx = '+list_to_mat(dg_dx[1])+';\n'
eq_h_block = '''
%h
if output.F
{0}
end
if output.Js
{1}
end
if output.Jx
{2}
end
if output.Jsn
{3}
end
if output.Jxn
{4}
end'''
# eq_h_block = eq_h_block.format(write_eqs(h_eqs, 'out1', 3),
# write_der_eqs(h_eqs, states_vars, 'out2', 3),
# write_der_eqs(h_eqs, controls, 'out3', 3),
# write_der_eqs(h_eqs, states_f, 'out4', 3),
# write_der_eqs(h_eqs, controls_f, 'out5', 3))
dh_ds = write_der_eqs(h_eqs, states_vars, 'out2', 3)
dh_dx = write_der_eqs(h_eqs, controls, 'out3', 3)
dh_ds_f = write_der_eqs(h_eqs, states_f, 'out4', 3)
dh_dx_f = write_der_eqs(h_eqs, controls_f, 'out5', 3)
eq_h_block = eq_h_block.format(write_eqs(h_eqs, 'out1', 3),
dh_ds[0],
dh_dx[0],
dh_ds_f[0],
dh_dx_f[0])
jac_struc += ' out1.hs = '+list_to_mat(dh_ds[1])+';\n'
jac_struc += ' out1.hx = '+list_to_mat(dh_dx[1])+';\n'
jac_struc += ' out1.hsnext = '+list_to_mat(dh_ds_f[1])+';\n'
jac_struc += ' out1.hxnext = '+list_to_mat(dh_dx_f[1])+';\n'
eq_hm_block = '''
% hmult
if output.hmult
{0}
end'''
eq_hm_block = eq_hm_block.format(write_eqs(hm_eqs, 'out6', 3))
if e_eqs:
equation_error_block = write_eqs(e_eqs, 'out1', 3)
else:
equation_error_block =''' out1 = [];'''
# Model informations
[y,x,params_values] = model.read_calibration()
vvs = model.variables
s_ss = [y[vvs.index(v)] for v in model['variables_groups']['states']]
x_ss = [y[vvs.index(v)] for v in model['variables_groups']['controls']]
model_ss = ''' out1 = {s_ss};
out2 = {x_ss};'''
model_ss = model_ss.format(s_ss = value_to_mat(s_ss).replace(';',''),
x_ss = value_to_mat(x_ss).replace(';',''))
if hm_eqs:
text = textmult.format(eq_bounds_block = eq_bounds_block,
filename = model.fname,
eq_fun_block = eq_f_block,
state_trans_block = eq_g_block,
exp_fun_block = eq_h_block,
exp_exp_mult_block = eq_hm_block,
equation_error_block = equation_error_block,
model_params = value_to_mat(params_values),
model_ss = model_ss,
jac_struc = jac_struc)
else:
text = text.format(eq_bounds_block = eq_bounds_block,
filename = model.fname,
eq_fun_block = eq_f_block,
state_trans_block = eq_g_block,
exp_fun_block = eq_h_block,
equation_error_block = equation_error_block,
model_params = value_to_mat(params_values),
model_ss = model_ss,
jac_struc = jac_struc)
return text
def process_output(self, solution_order=False, fname=None):
from dolo.numeric.perturbations_to_states import simple_global_representation
data = simple_global_representation(self.model, substitute_auxiliary=True, keep_auxiliary=True, solve_systems=True)
# print data['a_eqs']
# print data['f_eqs']
dmodel = self.model
model = dmodel
f_eqs = data['f_eqs']
g_eqs = data['g_eqs']
g_eqs = [map_function_to_expression(lambda x: timeshift(x,1),eq) for eq in g_eqs]
# h_eqs = data['h_eqs']
auxiliaries = data['auxiliaries']
states = data['states']
controls = data['controls']
# exp_vars = data['exp_vars']
#inf_bounds = data['inf_bounds']
#sup_bounds = data['sup_bounds']
controls_f = [v(1) for v in controls]
states_f = [v(1) for v in states]
sub_list = dict()
# for i,v in enumerate(exp_vars):
# sub_list[v] = 'z(:,{0})'.format(i+1)
for i,v in enumerate(controls):
sub_list[v] = 'x(:,{0})'.format(i+1)
sub_list[v(1)] = 'xnext(:,{0})'.format(i+1)
for i,v in enumerate(states):
sub_list[v] = 's(:,{0})'.format(i+1)
sub_list[v(1)] = 'snext(:,{0})'.format(i+1)
for i,v in enumerate(dmodel.shocks):
sub_list[v] = 'e(:,{0})'.format(i+1)
for i,v in enumerate(dmodel.parameters):
sub_list[v] = 'p({0})'.format(i+1)
text = '''function [model] = get_model()
model = model_info;
model.f = @f;
model.g = @g;
model.a = @a;
end
function [out1,out2,out3,out4,out5] = f(s,x,snext,xnext,p)
n = size(s,1);
{eq_fun_block}
end
function [out1,out2,out3] = g(s,x,e,p)
n = size(s,1);
{state_trans_block}
end
function [out1,out2,out3] = a(s,x,p)
n = size(s,1);
{aux_block}
end
function [out1] = model_info() % informations about the model
{model_info}
end
'''
from dolo.compiler.compiler import DicPrinter
dp = DicPrinter(sub_list)
def write_eqs(eq_l,outname='out1',ntabs=0):
eq_block = ' ' * ntabs + '{0} = zeros(n,{1});'.format(outname,len(eq_l))
for i,eq in enumerate(eq_l):
eq_block += '\n' + ' ' * ntabs + '{0}(:,{1}) = {2};'.format( outname, i+1, dp.doprint_matlab(eq,vectorize=True) )
return eq_block
def write_der_eqs(eq_l,v_l,lhs,ntabs=0):
eq_block = ' ' * ntabs + '{lhs} = zeros(n,{0},{1});'.format(len(eq_l),len(v_l),lhs=lhs)
eq_l_d = eqdiff(eq_l,v_l)
for i,eqq in enumerate(eq_l_d):
for j,eq in enumerate(eqq):
s = dp.doprint_matlab( eq, vectorize=True )
eq_block += '\n' + ' ' * ntabs + '{lhs}(:,{0},{1}) = {2}; % d eq_{eq_n} w.r.t. {vname}'.format(i+1,j+1,s,lhs=lhs,eq_n=i+1,vname=str(v_l[j]) )
return eq_block
# eq_bounds_block = write_eqs(inf_bounds,ntabs=2)
# eq_bounds_block += '\n'
# eq_bounds_block += write_eqs(sup_bounds,'out2',ntabs=2)
eq_f_block = '''
% f
{0}
if nargout >= 2
% df/ds
{1}
% df/dx
{2}
% df/dsnext
{3}
% df/dxnext
{4}
end
'''.format( write_eqs(f_eqs,'out1',3),
write_der_eqs(f_eqs,states,'out2',3),
write_der_eqs(f_eqs,controls,'out3',3),
write_der_eqs(f_eqs,states_f,'out4',3),
write_der_eqs(f_eqs,controls_f,'out5',3),
# write_der_eqs(f_eqs,exp_vars,'out4',3)
)
eq_g_block = '''
% g
{0}
if nargout >=2
% dg/ds
{1}
% dg/dx
{2}
end
'''.format( write_eqs(g_eqs,'out1',3),
write_der_eqs(g_eqs,states,'out2',3),
write_der_eqs(g_eqs,controls,'out3',3)
)
if 'a_eqs' in data:
a_eqs = data['a_eqs']
eq_a_block = '''
% a
{0}
if nargout >=2
% da/ds
{1}
% da/dx
{2}
end
'''.format( write_eqs(a_eqs,'out1',3),
write_der_eqs(a_eqs,states,'out2',3),
write_der_eqs(a_eqs,controls,'out3',3)
)
else:
eq_a_block = ''
# if not with_param_names:
# eq_h_block = 's=snext;\nx=xnext;\n'+eq_h_block
# param_def = 'p = [ ' + str.join(',',[p.name for p in dmodel.parameters]) + '];'
from dolo.misc.matlab import value_to_mat
# read model informations
[y,x,params_values] = model.read_calibration()
#params_values = '[' + str.join( ',', [ str( p ) for p in params] ) + '];'
vvs = model.variables
s_ss = [ y[vvs.index(v)] for v in model['variables_groups']['states'] ]
x_ss = [ y[vvs.index(v)] for v in model['variables_groups']['controls'] ]
model_info = '''
mod = struct;
mod.states = {states};
mod.controls = {controls};
mod.auxiliaries = {auxiliaries};
mod.parameters = {parameters};
mod.shocks = {shocks};
mod.s_ss = {s_ss};
mod.x_ss = {x_ss};
mod.params = {params_values};
'''.format(
states = '{{ {} }}'.format(str.join(',', ["'{}'".format(v) for v in states])),
controls = '{{ {} }}'.format(str.join(',', ["'{}'".format(v) for v in controls])),
auxiliaries = '{{ {} }}'.format(str.join(',', ["'{}'".format(v) for v in auxiliaries])),
parameters = '{{ {} }}'.format(str.join(',', ["'{}'".format(v) for v in model.parameters])),
shocks = '{{ {} }}'.format(str.join(',', ["'{}'".format(v) for v in model.shocks])),
s_ss = value_to_mat(s_ss),
x_ss = value_to_mat(x_ss),
params_values = value_to_mat(params_values)
)
if solution_order:
from dolo.numeric.perturbations_to_states import approximate_controls
ZZ = approximate_controls(self.model,order=solution_order, return_dr=False)
n_c = len(controls)
ZZ = [np.array(e) for e in ZZ]
ZZ = [e[:n_c,...] for e in ZZ] # keep only control vars. (x) not expectations (h)
solution = " mod.X = cell({0},1);\n".format(len(ZZ))
for i,zz in enumerate(ZZ):
solution += " mod.X{{{0}}} = {1};\n".format(i+1,value_to_mat(zz.real))
model_info += solution
model_info += ' out1 = mod;\n'
text = text.format(
# eq_bounds_block = eq_bounds_block,
mfname = fname if fname else 'mf_' + model.fname,
eq_fun_block=eq_f_block,
state_trans_block=eq_g_block,
aux_block=eq_a_block,
# exp_fun_block=eq_h_block,
# solution = solution,
model_info = model_info
)
return text
def process_output_recs(self, solution_order=False, fname=None):
data = self.read_model()
dmodel = self.model
model = dmodel
f_eqs = data['f_eqs']
g_eqs = data['g_eqs']
h_eqs = data['h_eqs']
states_vars = data['states_vars']
controls = data['controls']
exp_vars = data['exp_vars']
inf_bounds = data['inf_bounds']
sup_bounds = data['sup_bounds']
controls_f = [v(1) for v in controls]
states_f = [v(1) for v in states_vars]
sub_list = dict()
for i,v in enumerate(exp_vars):
sub_list[v] = 'z(:,{0})'.format(i+1)
for i,v in enumerate(controls):
sub_list[v] = 'x(:,{0})'.format(i+1)
sub_list[v(1)] = 'xnext(:,{0})'.format(i+1)
for i,v in enumerate(states_vars):
sub_list[v] = 's(:,{0})'.format(i+1)
sub_list[v(1)] = 'snext(:,{0})'.format(i+1)
for i,v in enumerate(dmodel.shocks):
sub_list[v] = 'e(:,{0})'.format(i+1)
for i,v in enumerate(dmodel.parameters):
sub_list[v] = 'p({0})'.format(i+1)
import sympy
sub_list[sympy.Symbol('inf')] = 'Inf'
text = '''function [out1,out2,out3,out4,out5] = {mfname}(flag,s,x,z,e,snext,xnext,p,out);
output = struct('F',1,'Js',0,'Jx',0,'Jsn',0,'Jxn',0,'Jz',0,'hmult',0);
if nargin == 9
output = catstruct(output,out);
voidcell = cell(1,5);
[out1,out2,out3,out4,out5] = voidcell{{:}};
else
if nargout >= 2, output.Js = 1; end
if nargout >= 3, output.Jx = 1; end
if nargout >= 4
if strcmpi(flag, 'f')
output.Jz = 1;
else
output.Jsn = 1;
end
end
if nargout >= 5, output.Jxn = 1; end
end
switch flag
case 'b';
n = size(s,1);
{eq_bounds_block}
case 'f';
n = size(s,1);
{eq_fun_block}
case 'g';
n = size(s,1);
{state_trans_block}
case 'h';
n = size(snext,1);
{exp_fun_block}
case 'e';
out1 = [];
case 'model'; % informations about the model
{model_info}
end
'''
from dolo.compiler.common import DicPrinter
dp = DicPrinter(sub_list)
def write_eqs(eq_l,outname='out1',ntabs=0):
eq_block = ' ' * ntabs + '{0} = zeros(n,{1});'.format(outname,len(eq_l))
for i,eq in enumerate(eq_l):
eq_block += '\n' + ' ' * ntabs + '{0}(:,{1}) = {2};'.format( outname, i+1, dp.doprint_matlab(eq,vectorize=True) )
return eq_block
def write_der_eqs(eq_l,v_l,lhs,ntabs=0):
eq_block = ' ' * ntabs + '{lhs} = zeros(n,{0},{1});'.format(len(eq_l),len(v_l),lhs=lhs)
eq_l_d = eqdiff(eq_l,v_l)
for i,eqq in enumerate(eq_l_d):
for j,eq in enumerate(eqq):
s = dp.doprint_matlab( eq, vectorize=True )
eq_block += '\n' + ' ' * ntabs + '{lhs}(:,{0},{1}) = {2}; % d eq_{eq_n} w.r.t. {vname}'.format(i+1,j+1,s,lhs=lhs,eq_n=i+1,vname=str(v_l[j]) )
return eq_block
eq_bounds_block = write_eqs(inf_bounds,ntabs=2)
eq_bounds_block += '\n'
eq_bounds_block += write_eqs(sup_bounds,'out2',ntabs=2)
eq_f_block = '''
% f
if output.F
{0}
end
% df/ds
if output.Js
{1}
end
% df/dx
if output.Jx
{2}
end
% df/dz
if output.Jz
{3}
end
'''.format( write_eqs(f_eqs,'out1',3),
write_der_eqs(f_eqs,states_vars,'out2',3),
write_der_eqs(f_eqs,controls,'out3',3),
write_der_eqs(f_eqs,exp_vars,'out4',3)
)
eq_g_block = '''
% g
if output.F
{0}
end
if output.Js
{1}
end
if output.Jx
{2}
end
'''.format( write_eqs(g_eqs,'out1',3),
write_der_eqs(g_eqs,states_vars,'out2',3),
write_der_eqs(g_eqs,controls,'out3',3)
)
eq_h_block = '''
%h
if output.F
{0}
end
if output.Js
{1}
end
if output.Jx
{2}
end
if output.Jsn
{3}
end
if output.Jxn
{4}
end
'''.format(
write_eqs(h_eqs,'out1',3),
write_der_eqs(h_eqs,states_vars,'out2',3),
write_der_eqs(h_eqs,controls,'out3',3),
write_der_eqs(h_eqs,states_f,'out4',3),
write_der_eqs(h_eqs,controls_f,'out5',3)
)
# if not with_param_names:
# eq_h_block = 's=snext;\nx=xnext;\n'+eq_h_block
# param_def = 'p = [ ' + str.join(',',[p.name for p in dmodel.parameters]) + '];'
from dolo.misc.matlab import value_to_mat
# read model informations
[y,x,params_values] = model.read_calibration()
#params_values = '[' + str.join( ',', [ str( p ) for p in params] ) + '];'
vvs = model.variables
s_ss = [ y[vvs.index(v)] for v in model['variables_groups']['states'] ]
x_ss = [ y[vvs.index(v)] for v in model['variables_groups']['controls'] ]
model_info = '''
mod = struct;
mod.s_ss = {s_ss};
mod.x_ss = {x_ss};
mod.params = {params_values};
'''.format(
s_ss = value_to_mat(s_ss),
x_ss = value_to_mat(x_ss),
params_values = value_to_mat(params_values)
)
if solution_order:
from dolo.numeric.perturbations_to_states import approximate_controls
ZZ = approximate_controls(self.model,order=solution_order)
n_c = len(controls)
ZZ = [np.array(e) for e in ZZ]
ZZ = [e[:n_c,...] for e in ZZ] # keep only control vars. (x) not expectations (h)
solution = " mod.X = cell({0},1);\n".format(len(ZZ))
for i,zz in enumerate(ZZ):
solution += " mod.X{{{0}}} = {1};\n".format(i+1,value_to_mat(zz))
model_info += solution
model_info += ' out1 = mod;\n'
text = text.format(
eq_bounds_block = eq_bounds_block,
mfname = fname if fname else 'mf_' + model.fname,
eq_fun_block=eq_f_block,
state_trans_block=eq_g_block,
exp_fun_block=eq_h_block,
# solution = solution,
model_info = model_info
)
return text
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.calculus 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 process_output_recs(self, solution_order=False, fname=None):
data = self.read_model()
dmodel = self.model
model = dmodel
f_eqs = data['f_eqs']
g_eqs = data['g_eqs']
h_eqs = data['h_eqs']
states_vars = data['states_vars']
controls = data['controls']
exp_vars = data['exp_vars']
inf_bounds = data['inf_bounds']
sup_bounds = data['sup_bounds']
controls_f = [v(1) for v in controls]
states_f = [v(1) for v in states_vars]
sub_list = dict()
for i,v in enumerate(exp_vars):
sub_list[v] = 'z(:,{0})'.format(i+1)
for i,v in enumerate(controls):
sub_list[v] = 'x(:,{0})'.format(i+1)
sub_list[v(1)] = 'xnext(:,{0})'.format(i+1)
for i,v in enumerate(states_vars):
sub_list[v] = 's(:,{0})'.format(i+1)
sub_list[v(1)] = 'snext(:,{0})'.format(i+1)
for i,v in enumerate(dmodel.shocks):
sub_list[v] = 'e(:,{0})'.format(i+1)
for i,v in enumerate(dmodel.parameters):
sub_list[v] = 'p({0})'.format(i+1)
import sympy
sub_list[sympy.Symbol('inf')] = 'Inf'
text = '''function [out1,out2,out3,out4,out5] = {mfname}(flag,s,x,z,e,snext,xnext,p,out);
output = struct('F',1,'Js',0,'Jx',0,'Jsn',0,'Jxn',0,'Jz',0,'hmult',0);
if nargin == 9
output = catstruct(output,out);
voidcell = cell(1,5);
[out1,out2,out3,out4,out5] = voidcell{{:}};
else
if nargout >= 2, output.Js = 1; end
if nargout >= 3, output.Jx = 1; end
if nargout >= 4
if strcmpi(flag, 'f')
output.Jz = 1;
else
output.Jsn = 1;
end
end
if nargout >= 5, output.Jxn = 1; end
end
switch flag
case 'b';
n = size(s,1);
{eq_bounds_block}
case 'f';
n = size(s,1);
{eq_fun_block}
case 'g';
n = size(s,1);
{state_trans_block}
case 'h';
n = size(snext,1);
{exp_fun_block}
case 'e';
out1 = [];
case 'model'; % informations about the model
{model_info}
end
'''
from dolo.compiler.common import DicPrinter
dp = DicPrinter(sub_list)
def write_eqs(eq_l,outname='out1',ntabs=0):
eq_block = ' ' * ntabs + '{0} = zeros(n,{1});'.format(outname,len(eq_l))
for i,eq in enumerate(eq_l):
eq_block += '\n' + ' ' * ntabs + '{0}(:,{1}) = {2};'.format( outname, i+1, dp.doprint_matlab(eq,vectorize=True) )
return eq_block
def write_der_eqs(eq_l,v_l,lhs,ntabs=0):
eq_block = ' ' * ntabs + '{lhs} = zeros(n,{0},{1});'.format(len(eq_l),len(v_l),lhs=lhs)
eq_l_d = eqdiff(eq_l,v_l)
for i,eqq in enumerate(eq_l_d):
for j,eq in enumerate(eqq):
s = dp.doprint_matlab( eq, vectorize=True )
eq_block += '\n' + ' ' * ntabs + '{lhs}(:,{0},{1}) = {2}; % d eq_{eq_n} w.r.t. {vname}'.format(i+1,j+1,s,lhs=lhs,eq_n=i+1,vname=str(v_l[j]) )
return eq_block
eq_bounds_block = write_eqs(inf_bounds,ntabs=2)
eq_bounds_block += '\n'
eq_bounds_block += write_eqs(sup_bounds,'out2',ntabs=2)
eq_f_block = '''
% f
if output.F
{0}
end
% df/ds
if output.Js
{1}
end
% df/dx
if output.Jx
{2}
end
% df/dz
if output.Jz
{3}
end
'''.format( write_eqs(f_eqs,'out1',3),
write_der_eqs(f_eqs,states_vars,'out2',3),
write_der_eqs(f_eqs,controls,'out3',3),
write_der_eqs(f_eqs,exp_vars,'out4',3)
)
eq_g_block = '''
% g
if output.F
{0}
end
if output.Js
{1}
end
if output.Jx
{2}
end
'''.format( write_eqs(g_eqs,'out1',3),
write_der_eqs(g_eqs,states_vars,'out2',3),
write_der_eqs(g_eqs,controls,'out3',3)
)
eq_h_block = '''
%h
if output.F
{0}
end
if output.Js
{1}
end
if output.Jx
{2}
end
if output.Jsn
{3}
end
if output.Jxn
{4}
end
'''.format(
write_eqs(h_eqs,'out1',3),
write_der_eqs(h_eqs,states_vars,'out2',3),
write_der_eqs(h_eqs,controls,'out3',3),
write_der_eqs(h_eqs,states_f,'out4',3),
write_der_eqs(h_eqs,controls_f,'out5',3)
)
# if not with_param_names:
# eq_h_block = 's=snext;\nx=xnext;\n'+eq_h_block
# param_def = 'p = [ ' + str.join(',',[p.name for p in dmodel.parameters]) + '];'
from dolo.misc.matlab import value_to_mat
# read model informations
[y,x,params_values] = model.read_calibration()
#params_values = '[' + str.join( ',', [ str( p ) for p in params] ) + '];'
vvs = model.variables
s_ss = [ y[vvs.index(v)] for v in model['variables_groups']['states'] ]
x_ss = [ y[vvs.index(v)] for v in model['variables_groups']['controls'] ]
model_info = '''
mod = struct;
mod.s_ss = {s_ss};
mod.x_ss = {x_ss};
mod.params = {params_values};
'''.format(
s_ss = value_to_mat(s_ss),
x_ss = value_to_mat(x_ss),
params_values = value_to_mat(params_values)
)
if solution_order:
from dolo.numeric.perturbations_to_states import approximate_controls
ZZ = approximate_controls(self.model,order=solution_order)
n_c = len(controls)
ZZ = [np.array(e) for e in ZZ]
ZZ = [e[:n_c,...] for e in ZZ] # keep only control vars. (x) not expectations (h)
solution = " mod.X = cell({0},1);\n".format(len(ZZ))
for i,zz in enumerate(ZZ):
solution += " mod.X{{{0}}} = {1};\n".format(i+1,value_to_mat(zz))
model_info += solution
model_info += ' out1 = mod;\n'
text = text.format(
eq_bounds_block = eq_bounds_block,
mfname = fname if fname else 'mf_' + model.fname,
eq_fun_block=eq_f_block,
state_trans_block=eq_g_block,
exp_fun_block=eq_h_block,
# solution = solution,
model_info = model_info
)
return text
def process_output_recs(self):
'''Main function that formats the model in recs format'''
import sympy
from dolo.compiler.common import DicPrinter
from dolo.misc.matlab import value_to_mat
data = self.read_model()
dmodel = self.model
model = dmodel
f_eqs = data['f_eqs']
g_eqs = data['g_eqs']
h_eqs = data['h_eqs']
hm_eqs = data['hm_eqs']
e_eqs = data['e_eqs']
states_vars = data['states_vars']
controls = data['controls']
exp_vars = data['exp_vars']
inf_bounds = data['inf_bounds']
sup_bounds = data['sup_bounds']
controls_f = [v(1) for v in controls]
states_f = [v(1) for v in states_vars]
sub_list = dict()
for i, v in enumerate(exp_vars):
sub_list[v] = 'z(:,{0})'.format(i + 1)
for i, v in enumerate(controls):
sub_list[v] = 'x(:,{0})'.format(i + 1)
sub_list[v(1)] = 'xnext(:,{0})'.format(i + 1)
for i, v in enumerate(states_vars):
sub_list[v] = 's(:,{0})'.format(i + 1)
sub_list[v(1)] = 'snext(:,{0})'.format(i + 1)
for i, v in enumerate(dmodel.shocks):
sub_list[v] = 'e(:,{0})'.format(i + 1)
for i, v in enumerate(dmodel.parameters):
sub_list[v] = 'p({0})'.format(i + 1)
sub_list[sympy.Symbol('inf')] = 'inf'
# Case h(s,x,e,sn,xn)
text = '''function [out1,out2,out3,out4,out5] = {filename}(flag,s,x,z,e,snext,xnext,p,output)
voidcell = cell(1,5);
[out1,out2,out3,out4,out5] = voidcell{{:}};
switch flag
case 'b'
n = size(s,1);
{eq_bounds_block}
case 'f'
n = size(s,1);
{eq_fun_block}
case 'g'
n = size(s,1);
{state_trans_block}
case 'h'
n = size(snext,1);
{exp_fun_block}
case 'e'
n = size(s,1);
{equation_error_block}
case 'params'
out1 = {model_params};
case 'ss'
{model_ss}
case 'J'
{jac_struc}
end'''
# Case h(.,.,.,sn,xn)*hmult(e)
textmult = '''function [out1,out2,out3,out4,out5,out6] = {filename}(flag,s,x,z,e,snext,xnext,p,output)
voidcell = cell(1,6);
[out1,out2,out3,out4,out5,out6] = voidcell{{:}};
switch flag
case 'b'
n = size(s,1);
{eq_bounds_block}
case 'f'
n = size(s,1);
{eq_fun_block}
case 'g'
n = size(s,1);
{state_trans_block}
case 'h'
n = size(snext,1);
{exp_fun_block}
{exp_exp_mult_block}
case 'e'
n = size(s,1);
{equation_error_block}
case 'params'
out1 = {model_params};
case 'ss'
{model_ss}
case 'J'
{jac_struc}
end'''
dp = DicPrinter(sub_list)
def write_eqs(eq_l, outname='out1', ntabs=0, default=None):
'''Format equations and bounds'''
if default:
eq_block = ' ' * ntabs + '{0} = ' + default + '(n,{1});'
eq_block = eq_block.format(outname, len(eq_l))
else:
eq_block = ' ' * ntabs + '{0} = zeros(n,{1});'.format(
outname, len(eq_l))
eq_template = '\n' + ' ' * ntabs + '{0}(:,{1}) = {2};'
for i, eq in enumerate(eq_l):
eq_txt = dp.doprint_matlab(eq, vectorize=True)
if eq_txt != default:
eq_block += eq_template.format(outname, i + 1, eq_txt)
return eq_block
def write_der_eqs(eq_l, v_l, lhs, ntabs=0):
'''Format Jacobians'''
eq_block = ' ' * ntabs + '{lhs} = zeros(n,{0},{1});'
eq_block = eq_block.format(len(eq_l), len(v_l), lhs=lhs)
eq_l_d = eqdiff(eq_l, v_l)
eq_template = '\n' + ' ' * ntabs + '{lhs}(:,{0},{1}) = {2}; % d eq_{eq_n} w.r.t. {vname}'
jac_struc = [[0 for i in range(len(v_l))]
for j in range(len(eq_l))]
for i, eqq in enumerate(eq_l_d):
for j, eq in enumerate(eqq):
s = dp.doprint_matlab(eq, vectorize=True)
if s != '0':
eq_block += eq_template.format(i + 1,
j + 1,
s,
lhs=lhs,
eq_n=i + 1,
vname=str(v_l[j]))
jac_struc[i][j] = 1
return [eq_block, jac_struc]
eq_bounds_block = '''
% b
{0}
% db/ds
if nargout==4
{1}
{2}
end'''
eq_bounds_values = write_eqs(inf_bounds, ntabs=2, default='-inf')
eq_bounds_values += '\n'
eq_bounds_values += write_eqs(sup_bounds,
'out2',
ntabs=2,
default='inf')
eq_bounds_jac_inf = write_der_eqs(inf_bounds, states_vars, 'out3', 3)
eq_bounds_jac_sup = write_der_eqs(sup_bounds, states_vars, 'out4', 3)
eq_bounds_block = eq_bounds_block.format(eq_bounds_values,
eq_bounds_jac_inf[0],
eq_bounds_jac_sup[0])
eq_f_block = '''
% f
if output.F
{0}
end
% df/ds
if output.Js
{1}
end
% df/dx
if output.Jx
{2}
end
% df/dz
if output.Jz
{3}
end'''
# eq_f_block = eq_f_block.format(write_eqs(f_eqs, 'out1', 3),
# write_der_eqs(f_eqs, states_vars, 'out2', 3),
# write_der_eqs(f_eqs, controls, 'out3', 3),
# write_der_eqs(f_eqs, exp_vars, 'out4', 3))
df_ds = write_der_eqs(f_eqs, states_vars, 'out2', 3)
df_dx = write_der_eqs(f_eqs, controls, 'out3', 3)
df_dz = write_der_eqs(f_eqs, exp_vars, 'out4', 3)
eq_f_block = eq_f_block.format(write_eqs(f_eqs, 'out1', 3), df_ds[0],
df_dx[0], df_dz[0])
jac_struc = ' out1.fs = ' + list_to_mat(df_ds[1]) + ';\n'
jac_struc += ' out1.fx = ' + list_to_mat(df_dx[1]) + ';\n'
jac_struc += ' out1.fz = ' + list_to_mat(df_dz[1]) + ';\n'
eq_g_block = '''
% g
if output.F
{0}
end
if output.Js
{1}
end
if output.Jx
{2}
end'''
# eq_g_block = eq_g_block.format(write_eqs(g_eqs, 'out1', 3),
# write_der_eqs(g_eqs, states_vars, 'out2', 3),
# write_der_eqs(g_eqs, controls, 'out3', 3))
dg_ds = write_der_eqs(g_eqs, states_vars, 'out2', 3)
dg_dx = write_der_eqs(g_eqs, controls, 'out3', 3)
eq_g_block = eq_g_block.format(write_eqs(g_eqs, 'out1', 3), dg_ds[0],
dg_dx[0])
jac_struc += ' out1.gs = ' + list_to_mat(dg_ds[1]) + ';\n'
jac_struc += ' out1.gx = ' + list_to_mat(dg_dx[1]) + ';\n'
eq_h_block = '''
%h
if output.F
{0}
end
if output.Js
{1}
end
if output.Jx
{2}
end
if output.Jsn
{3}
end
if output.Jxn
{4}
end'''
# eq_h_block = eq_h_block.format(write_eqs(h_eqs, 'out1', 3),
# write_der_eqs(h_eqs, states_vars, 'out2', 3),
# write_der_eqs(h_eqs, controls, 'out3', 3),
# write_der_eqs(h_eqs, states_f, 'out4', 3),
# write_der_eqs(h_eqs, controls_f, 'out5', 3))
dh_ds = write_der_eqs(h_eqs, states_vars, 'out2', 3)
dh_dx = write_der_eqs(h_eqs, controls, 'out3', 3)
dh_ds_f = write_der_eqs(h_eqs, states_f, 'out4', 3)
dh_dx_f = write_der_eqs(h_eqs, controls_f, 'out5', 3)
eq_h_block = eq_h_block.format(write_eqs(h_eqs, 'out1', 3), dh_ds[0],
dh_dx[0], dh_ds_f[0], dh_dx_f[0])
jac_struc += ' out1.hs = ' + list_to_mat(dh_ds[1]) + ';\n'
jac_struc += ' out1.hx = ' + list_to_mat(dh_dx[1]) + ';\n'
jac_struc += ' out1.hsnext = ' + list_to_mat(dh_ds_f[1]) + ';\n'
jac_struc += ' out1.hxnext = ' + list_to_mat(dh_dx_f[1]) + ';\n'
eq_hm_block = '''
% hmult
if output.hmult
{0}
end'''
eq_hm_block = eq_hm_block.format(write_eqs(hm_eqs, 'out6', 3))
if e_eqs:
equation_error_block = write_eqs(e_eqs, 'out1', 3)
else:
equation_error_block = ''' out1 = [];'''
# Model informations
[y, x, params_values] = model.read_calibration()
vvs = model.variables
s_ss = [y[vvs.index(v)] for v in model['variables_groups']['states']]
x_ss = [y[vvs.index(v)] for v in model['variables_groups']['controls']]
model_ss = ''' out1 = {s_ss};
out2 = {x_ss};'''
model_ss = model_ss.format(s_ss=value_to_mat(s_ss).replace(';', ''),
x_ss=value_to_mat(x_ss).replace(';', ''))
if hm_eqs:
text = textmult.format(eq_bounds_block=eq_bounds_block,
filename=model.fname,
eq_fun_block=eq_f_block,
state_trans_block=eq_g_block,
exp_fun_block=eq_h_block,
exp_exp_mult_block=eq_hm_block,
equation_error_block=equation_error_block,
model_params=value_to_mat(params_values),
model_ss=model_ss,
jac_struc=jac_struc)
else:
text = text.format(eq_bounds_block=eq_bounds_block,
filename=model.fname,
eq_fun_block=eq_f_block,
state_trans_block=eq_g_block,
exp_fun_block=eq_h_block,
equation_error_block=equation_error_block,
model_params=value_to_mat(params_values),
model_ss=model_ss,
jac_struc=jac_struc)
return text
