def __get_compiled_functions__(self, order=1):
# constructs arguments of function f(y(1),y,y(-1),e,p)
vv = self.symbols['variables']
syms = [(v,1) for v in vv] + [(v,0) for v in vv] + [(v,-1) for v in vv]
syms += [(s,0) for s in self.symbols['shocks']]
params = self.symbols['parameters']
# contsruct list of equations to differentiate
# TODO: replace ugly splits, by call to equation parser:
eqs = []
for eq in self.symbolic.equations:
m = str.split(eq,'=')
if len(m) == 2:
s = '{} - ({})'.format(m[1].strip(),m[0].strip())
s = str.strip(s)
else:
s = eq
eqs.append(s)
from dolo.compiler.function_compiler_sympy import compile_higher_order_function
f_dynamic = compile_higher_order_function(eqs, syms, params,
order=order, funname='f_dynamic')
e = self.calibration['shocks']
f_static = lambda y, p: f_dynamic(numpy.concatenate([y,y,y,e]),p, order=0)
functions = {
'f_static': f_static,
'f_dynamic': f_dynamic,
}
return functions
def __get_compiled_functions__(self, order=1):
# constructs arguments of function f(y(1),y,y(-1),e,p)
vv = self.symbols['variables']
syms = [(v,1) for v in vv] + [(v,0) for v in vv] + [(v,-1) for v in vv]
syms += [(s,0) for s in self.symbols['shocks']]
params = self.symbols['parameters']
# contsruct list of equations to differentiate
# TODO: replace ugly splits, by call to equation parser:
eqs = []
for eq in self.symbolic.equations:
m = str.split(eq,'=')
if len(m) == 2:
s = '{} - ({})'.format(m[1].strip(),m[0].strip())
s = str.strip(s)
else:
s = eq
eqs.append(s)
from dolo.compiler.function_compiler_sympy import compile_higher_order_function
f_dynamic = compile_higher_order_function(eqs, syms, params,
order=order, funname='f_dynamic')
e = self.calibration['shocks']
f_static = lambda y, p: f_dynamic(numpy.concatenate([y,y,y,e]),p, order=0)
functions = {
'f_static': f_static,
'f_dynamic': f_dynamic,
}
return functions
def __compile_functions__(self):
# constructs arguments of function f(y(1),y,y(-1),e,p)
vv = self.symbols["variables"]
syms = [(v, 1) for v in vv] + [(v, 0) for v in vv] + [(v, -1) for v in vv]
syms += [(s, 0) for s in self.symbols["shocks"]]
params = self.symbols["parameters"]
# contsruct list of equations to differentiate
# TODO: replace ugly splits, by call to equation parser:
eqs = []
for eq in self.symbolic.equations:
m = str.split(eq, "=")
if len(m) == 2:
s = "{} - ({})".format(m[1].strip(), m[0].strip())
s = str.strip(s)
else:
s = eq
eqs.append(s)
from dolo.compiler.function_compiler_sympy import compile_higher_order_function
f_dynamic = compile_higher_order_function(eqs, syms, params, order=3, funname="f_dynamic")
e = self.calibration["shocks"]
f_static = lambda y, p: f_dynamic(numpy.concatenate([y, y, y, e]), p, order=0)
self.functions = {"f_static": f_static, "f_dynamic": f_dynamic}
def model_to_fg(model, order=2):
# compile f, g function at higher order
all_variables = sum(
[model.symbols[e] for e in model.symbols if e != 'parameters'], [])
all_dvariables = ([(d, 0) for d in all_variables] +
[(d, 1)
for d in all_variables] + [(d, -1)
for d in all_variables])
psyms = [(e, 0) for e in model.symbols['parameters']]
if hasattr(model.symbolic, 'definitions'):
definitions = model.symbolic.definitions
else:
definitions = {}
d = dict()
for k in definitions:
v = parse_equation(definitions[k], all_variables, to_sympy=True)
kk = stringify((k, 0))
kk_m1 = stringify((k, -1))
kk_1 = stringify((k, 1))
d[sympy.Symbol(kk)] = v
d[sympy.Symbol(kk_m1)] = timeshift(v, all_variables, -1)
d[sympy.Symbol(kk_1)] = timeshift(v, all_variables, 1)
f_eqs = model.symbolic.equations['arbitrage']
f_eqs = [parse_equation(eq, all_variables, to_sympy=True) for eq in f_eqs]
f_eqs = [eq.subs(d) for eq in f_eqs]
g_eqs = model.symbolic.equations['transition']
g_eqs = [
parse_equation(eq, all_variables, to_sympy=True, substract_lhs=False)
for eq in g_eqs
]
#solve_recursively
from collections import OrderedDict
dd = OrderedDict()
for eq in g_eqs:
dd[eq[0]] = eq[1].subs(dd).subs(d)
g_eqs = dd.values()
f_syms = [(e,0) for e in model.symbols['states']] + \
[(e,0) for e in model.symbols['controls']] + \
[(e,1) for e in model.symbols['states']] + \
[(e,1) for e in model.symbols['controls']]
g_syms = [(e,-1) for e in model.symbols['states']] + \
[(e,-1) for e in model.symbols['controls']] + \
[(e,0) for e in model.symbols['shocks']]
params = model.symbols['parameters']
f = compile_higher_order_function(f_eqs,
f_syms,
params,
order=order,
funname='f',
return_code=False,
compile=False)
g = compile_higher_order_function(g_eqs,
g_syms,
params,
order=order,
funname='g',
return_code=False,
compile=False)
# cache result
model.__higher_order_functions__ = dict(f=f, g=g)
model.__highest_order__ = order
return [f, g]
def model_to_fg(model, order=2):
if hasattr(model, '__higher_order_functions__') and model.__highest_order__ >= order:
f = model.__higher_order_functions__['f']
g = model.__higher_order_functions__['g']
return [f, g]
all_variables = sum([model.symbols[e] for e in model.symbols if e != 'parameters'], [])
all_dvariables = ([(d, 0) for d in all_variables] +
[(d, 1) for d in all_variables] +
[(d, -1) for d in all_variables])
psyms = [(e,0) for e in model.symbols['parameters']]
if hasattr(model.symbolic, 'definitions'):
definitions = model.symbolic.definitions
else:
definitions = {}
ddef = dict()
for k in definitions:
v = parse_equation(definitions[k], all_dvariables + psyms, to_sympy=True)
ddef[sympy.Symbol(k)] = v
# all_sym_variables = [std_date_symbol(s,0) for s in all_variables]
params = model.symbols['parameters']
f_eqs = model.symbolic.equations['arbitrage']
f_eqs = [parse_equation(eq, all_dvariables + psyms, to_sympy=True) for eq in f_eqs]
f_eqs = [eq.subs(ddef) for eq in f_eqs] # TODO : replace it everywhere else
y_eqs = model.symbolic.equations['auxiliary']
syms = [(e, 0) for e in model.symbols['states']] + \
[(e, 0) for e in model.symbols['controls']] + \
[(e, 0) for e in model.symbols['auxiliaries']]
# Solve recursively
y_eqs = [parse_equation(eq, all_dvariables+psyms, to_sympy=True, substract_lhs=False) for eq in y_eqs]
d = {}
for eq in y_eqs:
d[eq[0]] = eq[1].subs(d)
# Construct dictionary
for k in list(d.keys()):
d[timeshift(k,all_variables,1)] = timeshift(d[k],all_variables,1)
d[timeshift(k,all_variables,-1)] = timeshift(d[k],all_variables,-1)
f_eqs = [eq.subs(d) for eq in f_eqs]
g_eqs = model.symbolic.equations['transition']
g_eqs = [parse_equation(eq, all_dvariables + psyms, to_sympy=True, substract_lhs=False) for eq in g_eqs]
#solve_recursively
from collections import OrderedDict
dd = OrderedDict()
for eq in g_eqs:
dd[eq[0]] = eq[1].subs(dd).subs(d)
g_eqs = dd.values()
syms = [(e,-1) for e in model.symbols['states']] + \
[(e,-1) for e in model.symbols['controls']] + \
[(e,-1) for e in model.symbols['auxiliaries']] + \
[(e,0) for e in model.symbols['shocks']] + \
[(e,0) for e in model.symbols['states']]
f_syms = [(e,0) for e in model.symbols['states']] + \
[(e,0) for e in model.symbols['controls']] + \
[(e,1) for e in model.symbols['states']] + \
[(e,1) for e in model.symbols['controls']]
g_syms = [(e,-1) for e in model.symbols['states']] + \
[(e,-1) for e in model.symbols['controls']] + \
[(e,0) for e in model.symbols['shocks']]
f = compile_higher_order_function(f_eqs, f_syms, params, order=order,
funname='f', return_code=False, compile=False)
g = compile_higher_order_function(g_eqs, g_syms, params, order=order,
funname='g', return_code=False, compile=False)
# cache result
model.__higher_order_functions__ = dict(f=f, g=g)
model.__highest_order__ = order
return [f, g]
def model_to_fg(model, order=2):
# compile f, g function at higher order
all_variables = sum(
[model.symbols[e] for e in model.symbols if e != "parameters"], [])
all_dvariables = ([(d, 0) for d in all_variables] +
[(d, 1)
for d in all_variables] + [(d, -1)
for d in all_variables])
psyms = [(e, 0) for e in model.symbols["parameters"]]
definitions = model.definitions
d = dict()
for k in definitions:
v = parse_equation(definitions[k], all_variables, to_sympy=True)
kk = stringify_symbol((k, 0))
kk_m1 = stringify_symbol((k, -1))
kk_1 = stringify_symbol((k, 1))
d[sympy.Symbol(kk)] = v
d[sympy.Symbol(kk_m1)] = timeshift(v, all_variables, -1)
d[sympy.Symbol(kk_1)] = timeshift(v, all_variables, 1)
f_eqs = model.equations["arbitrage"]
f_eqs = [parse_equation(eq, all_variables, to_sympy=True) for eq in f_eqs]
f_eqs = [eq.subs(d) for eq in f_eqs]
g_eqs = model.equations["transition"]
g_eqs = [
parse_equation(eq, all_variables, to_sympy=True, substract_lhs=False)
for eq in g_eqs
]
# solve_recursively
dd = dict()
for eq in g_eqs:
dd[eq[0]] = eq[1].subs(dd).subs(d)
g_eqs = dd.values()
f_syms = ([(e, 0) for e in model.symbols["states"]] +
[(e, 0) for e in model.symbols["controls"]] +
[(e, 1) for e in model.symbols["states"]] +
[(e, 1) for e in model.symbols["controls"]])
g_syms = ([(e, -1) for e in model.symbols["states"]] +
[(e, -1) for e in model.symbols["controls"]] +
[(e, 0) for e in model.symbols["exogenous"]])
params = model.symbols["parameters"]
f = compile_higher_order_function(
f_eqs,
f_syms,
params,
order=order,
funname="f",
return_code=False,
compile=False,
)
g = compile_higher_order_function(
g_eqs,
g_syms,
params,
order=order,
funname="g",
return_code=False,
compile=False,
)
# cache result
model.__higher_order_functions__ = dict(f=f, g=g)
model.__highest_order__ = order
return [f, g]
def model_to_fg(model, order=2):
# compile f, g function at higher order
all_variables = sum(
[model.symbols[e] for e in model.symbols if e != 'parameters'], [])
all_dvariables = ([(d, 0) for d in all_variables] + [
(d, 1) for d in all_variables
] + [(d, -1) for d in all_variables])
psyms = [(e, 0) for e in model.symbols['parameters']]
definitions = model.definitions
d = dict()
for k in definitions:
v = parse_equation(definitions[k], all_variables, to_sympy=True)
kk = stringify_symbol((k, 0))
kk_m1 = stringify_symbol((k, -1))
kk_1 = stringify_symbol((k, 1))
d[sympy.Symbol(kk)] = v
d[sympy.Symbol(kk_m1)] = timeshift(v, all_variables, -1)
d[sympy.Symbol(kk_1)] = timeshift(v, all_variables, 1)
f_eqs = model.equations['arbitrage']
f_eqs = [parse_equation(eq, all_variables, to_sympy=True) for eq in f_eqs]
f_eqs = [eq.subs(d) for eq in f_eqs]
g_eqs = model.equations['transition']
g_eqs = [
parse_equation(eq, all_variables, to_sympy=True, substract_lhs=False)
for eq in g_eqs
]
#solve_recursively
dd = dict()
for eq in g_eqs:
dd[eq[0]] = eq[1].subs(dd).subs(d)
g_eqs = dd.values()
f_syms = [(e,0) for e in model.symbols['states']] + \
[(e,0) for e in model.symbols['controls']] + \
[(e,1) for e in model.symbols['states']] + \
[(e,1) for e in model.symbols['controls']]
g_syms = [(e,-1) for e in model.symbols['states']] + \
[(e,-1) for e in model.symbols['controls']] + \
[(e,0) for e in model.symbols['exogenous']]
params = model.symbols['parameters']
f = compile_higher_order_function(
f_eqs,
f_syms,
params,
order=order,
funname='f',
return_code=False,
compile=False)
g = compile_higher_order_function(
g_eqs,
g_syms,
params,
order=order,
funname='g',
return_code=False,
compile=False)
# cache result
model.__higher_order_functions__ = dict(f=f, g=g)
model.__highest_order__ = order
return [f, g]
def model_to_fg(model, order=2):
# compile f, g function at higher order
all_variables = sum([model.symbols[e] for e in model.symbols if e != 'parameters'], [])
all_dvariables = ([(d, 0) for d in all_variables] +
[(d, 1) for d in all_variables] +
[(d, -1) for d in all_variables])
psyms = [(e,0) for e in model.symbols['parameters']]
sds = StandardizeDatesSimple(all_dvariables)
if hasattr(model.symbolic, 'definitions'):
definitions = model.symbolic.definitions
else:
definitions = {}
d = dict()
for k in definitions:
v = parse_equation(definitions[k], all_dvariables + psyms, to_sympy=True)
kk = std_date_symbol(k, 0)
d[sympy.Symbol(kk)] = v
for k in list(d.keys()):
d[timeshift(k, all_variables, 1)] = timeshift(d[k], all_variables, 1)
d[timeshift(k, all_variables, -1)] = timeshift(d[k], all_variables, -1)
f_eqs = model.symbolic.equations['arbitrage']
f_eqs = [parse_equation(eq, all_dvariables + psyms, to_sympy=True) for eq in f_eqs]
f_eqs = [eq.subs(d) for eq in f_eqs]
g_eqs = model.symbolic.equations['transition']
g_eqs = [parse_equation(eq, all_dvariables + psyms, to_sympy=True, substract_lhs=False) for eq in g_eqs]
#solve_recursively
from collections import OrderedDict
dd = OrderedDict()
for eq in g_eqs:
dd[eq[0]] = eq[1].subs(dd).subs(d)
g_eqs = dd.values()
f_syms = [(e,0) for e in model.symbols['states']] + \
[(e,0) for e in model.symbols['controls']] + \
[(e,1) for e in model.symbols['states']] + \
[(e,1) for e in model.symbols['controls']]
g_syms = [(e,-1) for e in model.symbols['states']] + \
[(e,-1) for e in model.symbols['controls']] + \
[(e,0) for e in model.symbols['shocks']]
params = model.symbols['parameters']
f = compile_higher_order_function(f_eqs, f_syms, params, order=order,
funname='f', return_code=False, compile=False)
g = compile_higher_order_function(g_eqs, g_syms, params, order=order,
funname='g', return_code=False, compile=False)
# cache result
model.__higher_order_functions__ = dict(f=f, g=g)
model.__highest_order__ = order
return [f, g]
