def parse_yaml_text(txt,verbose=False):
'''
Imports the content of a modfile into the current interpreter scope
'''
txt = txt.replace('..','-')
txt = txt.replace('--','-')
txt = txt.replace('^','**')
raw_dict = yaml.load(txt)
if verbose == True:
print('YAML file successfully parsed')
declarations = raw_dict['declarations']
# check
if 'controls' in declarations:
variables_groups = OrderedDict()
known_types = ['states','controls','expectations','auxiliary','auxiliary_2']
for vtype in known_types:
if vtype in declarations:
variables_groups[vtype] = [Variable(vn,0) for vn in declarations[vtype]]
variables_ordering = sum(variables_groups.values(),[])
else:
vnames = declarations['variables']
variables_ordering = [Variable(vn,0) for vn in vnames]
variables_groups = None
parameters_ordering = [Parameter(vn) for vn in declarations['parameters']]
shocks_ordering = [Shock(vn,0) for vn in declarations['shocks']]
context = [(s.name,s) for s in variables_ordering + parameters_ordering + shocks_ordering]
context = dict(context)
# add some common functions
for f in [sympy.log, sympy.exp,
sympy.sin, sympy.cos, sympy.tan,
sympy.asin, sympy.acos, sympy.atan,
sympy.sinh, sympy.cosh, sympy.tanh,
sympy.pi]:
context[str(f)] = f
context['sqrt'] = sympy.sqrt
import re
# we recognize two kinds of equations:
# lhs = rhs
# lhs | comp where comp is a complementarity condition
equations = []
equations_groups = OrderedDict()
raw_equations = raw_dict['equations']
if isinstance(raw_equations,dict): # tests whether there are groups of equations
for groupname in raw_equations.keys():
equations_groups[groupname] = []
for raw_eq in raw_equations[groupname]: # Modfile is supposed to represent a global model. TODO: change it
teqg = raw_eq.split('|')
teq = teqg[0]
if '=' in teq:
lhs,rhs = str.split(teq,'=')
else:
lhs = teq
rhs = '0'
try:
lhs = eval(lhs,context)
rhs = eval(rhs,context)
except Exception as e:
print('Error parsing equation : ' + teq)
print str(e)
raise e
eq = Equation(lhs,rhs)
eq.tag(eq_type=groupname)
if len(teqg)>1:
comp = teqg[1]
eq.tag(complementarity=comp)
equations.append(eq)
#equations_groups[groupname].append( eq )
else:
for teq in raw_equations:
if '=' in teq:
lhs,rhs = str.split(teq,'=')
else:
lhs = teq
rhs = '0'
try:
lhs = eval(lhs,context)
rhs = eval(rhs,context)
except Exception as e:
print('Error parsing equations : ' + teq)
print str(e)
eq = Equation(lhs,rhs)
equations.append(eq)
equations_groups = None
parameters_values = {}
init_values = {}
covariances = None
if 'calibration' in raw_dict:
calibration = raw_dict['calibration']
if 'parameters' in calibration:
parameters_values = [ (Parameter(k), eval(str(v),context)) for k,v in calibration['parameters'].iteritems() ]
parameters_values = dict(parameters_values)
#steady_state = raw_dict['steady_state']
if 'steady_state' in calibration:
init_values = [ (Variable(vn,0), eval(str(value),context)) for vn,value in calibration['steady_state'].iteritems() ]
init_values = dict(init_values)
if 'covariances' in calibration:
context['sympy'] = sympy
covariances = eval('sympy.Matrix({0})'.format( calibration['covariances'] ), context)
else:
covariances = None # to avoid importing numpy
model_dict = {
'variables_ordering': variables_ordering,
'parameters_ordering': parameters_ordering,
'shocks_ordering': shocks_ordering,
'variables_groups': variables_groups,
'equations_groups': equations_groups,
'equations': equations,
'parameters_values': parameters_values,
'init_values': init_values,
'covariances': covariances
}
if 'model_type' in raw_dict:
model_dict['model_type'] = raw_dict['model_type']
model_dict['original_data'] = raw_dict
model = Model(**model_dict)
model.check_consistency(auto_remove_variables=False)
return model
def parse_yaml_text(txt, verbose=False):
'''
Imports the content of a modfile into the current interpreter scope
'''
txt = txt.replace('..', '-')
txt = txt.replace('--', '-')
txt = txt.replace('^', '**')
raw_dict = yaml.load(txt)
if verbose == True:
print('YAML file successfully parsed')
declarations = raw_dict['declarations']
# check
if 'controls' in declarations:
variables_groups = OrderedDict()
known_types = [
'states', 'controls', 'expectations', 'auxiliary', 'auxiliary_2'
]
for vtype in known_types:
if vtype in declarations:
variables_groups[vtype] = [
Variable(vn, 0) for vn in declarations[vtype]
]
variables_ordering = sum(variables_groups.values(), [])
else:
vnames = declarations['variables']
variables_ordering = [Variable(vn, 0) for vn in vnames]
variables_groups = None
parameters_ordering = [Parameter(vn) for vn in declarations['parameters']]
shocks_ordering = [Shock(vn, 0) for vn in declarations['shocks']]
context = [
(s.name, s)
for s in variables_ordering + parameters_ordering + shocks_ordering
]
context = dict(context)
# add some common functions
for f in [
sympy.log, sympy.exp, sympy.sin, sympy.cos, sympy.tan, sympy.asin,
sympy.acos, sympy.atan, sympy.sinh, sympy.cosh, sympy.tanh,
sympy.pi
]:
context[str(f)] = f
context['sqrt'] = sympy.sqrt
import re
# we recognize two kinds of equations:
# lhs = rhs
# lhs | comp where comp is a complementarity condition
equations = []
equations_groups = OrderedDict()
raw_equations = raw_dict['equations']
if isinstance(raw_equations,
dict): # tests whether there are groups of equations
for groupname in raw_equations.keys():
equations_groups[groupname] = []
for raw_eq in raw_equations[
groupname]: # Modfile is supposed to represent a global model. TODO: change it
teqg = raw_eq.split('|')
teq = teqg[0]
if '=' in teq:
lhs, rhs = str.split(teq, '=')
else:
lhs = teq
rhs = '0'
try:
lhs = eval(lhs, context)
rhs = eval(rhs, context)
except Exception as e:
print('Error parsing equation : ' + teq)
print str(e)
raise e
eq = Equation(lhs, rhs)
eq.tag(eq_type=groupname)
if len(teqg) > 1:
comp = teqg[1]
eq.tag(complementarity=comp)
equations.append(eq)
#equations_groups[groupname].append( eq )
else:
for teq in raw_equations:
if '=' in teq:
lhs, rhs = str.split(teq, '=')
else:
lhs = teq
rhs = '0'
try:
lhs = eval(lhs, context)
rhs = eval(rhs, context)
except Exception as e:
print('Error parsing equations : ' + teq)
print str(e)
eq = Equation(lhs, rhs)
equations.append(eq)
equations_groups = None
parameters_values = {}
init_values = {}
covariances = None
if 'calibration' in raw_dict:
calibration = raw_dict['calibration']
if 'parameters' in calibration:
parameters_values = [
(Parameter(k), eval(str(v), context))
for k, v in calibration['parameters'].iteritems()
]
parameters_values = dict(parameters_values)
#steady_state = raw_dict['steady_state']
if 'steady_state' in calibration:
init_values = [
(Variable(vn, 0), eval(str(value), context))
for vn, value in calibration['steady_state'].iteritems()
]
init_values = dict(init_values)
if 'covariances' in calibration:
context['sympy'] = sympy
covariances = eval(
'sympy.Matrix({0})'.format(calibration['covariances']),
context)
else:
covariances = None # to avoid importing numpy
model_dict = {
'variables_ordering': variables_ordering,
'parameters_ordering': parameters_ordering,
'shocks_ordering': shocks_ordering,
'variables_groups': variables_groups,
'equations_groups': equations_groups,
'equations': equations,
'parameters_values': parameters_values,
'init_values': init_values,
'covariances': covariances
}
if 'model_type' in raw_dict:
model_dict['model_type'] = raw_dict['model_type']
model_dict['original_data'] = raw_dict
model = Model(**model_dict)
model.check_consistency(auto_remove_variables=False)
return model
def read_model(self):
if self.__transformed_model__:
return self.__transformed_model__
dmodel = Model(**self.model) # copy the model
dmodel.check_consistency(auto_remove_variables=False)
def_eqs = [eq for eq in dmodel.equations if eq.tags['eq_type'] in ('def', 'auxiliary')]
from dolo.symbolic.symbolic import map_function_to_expression
from dolo.symbolic.symbolic import Variable
def timeshift(v,n):
if isinstance(v,Variable):
return v(n)
else:
return v
import sympy
#### build substitution dict
def_dict = {}
for eq in def_eqs:
v = eq.lhs
rhs = sympy.sympify( eq.rhs )
def_dict[v] = rhs
def_dict[v(1)] = map_function_to_expression( lambda x: timeshift(x,1), rhs)
new_equations = []
tbr = []
for i,eq in enumerate(dmodel.equations) :
if not ('def' == eq.tags['eq_type']):
lhs = sympy.sympify( eq.lhs ).subs(def_dict)
rhs = sympy.sympify( eq.rhs ).subs(def_dict)
neq = Equation(lhs,rhs).tag(**eq.tags)
new_equations.append( neq )
dmodel['equations'] = new_equations
dmodel.check_consistency()
f_eqs = [eq for eq in dmodel.equations if eq.tags['eq_type'] in ('f','arbitrage')]
g_eqs = [eq for eq in dmodel.equations if eq.tags['eq_type'] in ('g','transition')]
h_eqs = [eq for eq in dmodel.equations if eq.tags['eq_type'] in ('h','expectation')]
states_vars = [eq.lhs for eq in g_eqs]
exp_vars = [eq.lhs for eq in h_eqs]
controls = set(dmodel.variables) - set(states_vars + exp_vars)
controls = list(controls)
states_vars = [v for v in dmodel.variables if v in states_vars]
exp_vars = [v for v in dmodel.variables if v in exp_vars]
controls = [v for v in dmodel.variables if v in controls]
# now we remove the left side of equations
f_eqs = [eq.gap for eq in f_eqs]
g_eqs = [eq.rhs for eq in g_eqs]
h_eqs = [eq.rhs for eq in h_eqs]
g_eqs = [map_function_to_expression(lambda x: timeshift(x,1),eq) for eq in g_eqs]
#h_eqs = [map_function_to_expression(lambda x: timeshift(x,-1),eq) for eq in h_eqs] #no
# sub_list[v] = v.name
# read complementarity conditions
compcond = {}
of_eqs = [eq for eq in dmodel.equations if eq.tags['eq_type'] in ('f','arbitrage')]
locals = {}
import sympy
locals['inf'] = sympy.Symbol('inf')
locals['log'] = sympy.log # this should be more generic
locals['exp'] = sympy.exp
for v in dmodel.variables + dmodel.parameters:
locals[v.name] = v
import re
compregex = re.compile('(.*)<=(.*)<=(.*)')
for eq in of_eqs:
tg = eq.tags['complementarity']
[lhs,mhs,rhs] = compregex.match(tg).groups()
[lhs,mhs,rhs] = [dmodel.eval_string(x) for x in [lhs,mhs,rhs] ]
compcond[mhs] = (lhs,rhs)
complementarities = [compcond[v] for v in controls]
inf_bounds = [c[0] for c in complementarities]
sup_bounds = [c[1] for c in complementarities]
data = {
'f_eqs': f_eqs,
'g_eqs': g_eqs,
'h_eqs': h_eqs,
'controls': controls,
'states_vars': states_vars,
'exp_vars': exp_vars,
'inf_bounds': inf_bounds,
'sup_bounds': sup_bounds
}
self.__transformed_model__ = data # cache computation
return data
