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): '''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