def process_output(self, recipe=None):
recipe = self.recipe
model = self.model
parms = model.symbols_s['parameters']
fun_text = ''
for eqg in self.model.equations_groups:
args = []
is_a_definition = 'definition' in recipe['equation_type'][eqg]
if is_a_definition:
arg_specs = recipe['equation_type'][eqg]['rhs']
else:
arg_specs = recipe['equation_type'][eqg]
arg_names = []
for syms in arg_specs:
[sgn,time] = syms
if syms[0] == 'shocks':
args.append( [ s(time) for s in model.symbols_s['shocks'] ] )
else:
args.append( [ s(time) for s in model.symbols_s[sgn] ] )
if time == 1:
stime = '_f'
elif time == -1:
stime = '_p'
else:
stime = ''
arg_names.append( sgn + stime)
equations = self.model.equations_groups[eqg]
if is_a_definition:
from dolo.compiler.common import solve_recursive_block
equations = solve_recursive_block(equations)
equations = [eq.rhs for eq in equations]
else:
equations = [eq.gap for eq in equations]
from dolo.compiler.function_compiler_julia import compile_multiargument_function
txt = compile_multiargument_function(equations, args, arg_names, parms, fname = eqg)
fun_text += txt
# the following part only makes sense for fga models
calib = model.calibration
cc = calib.copy()
cc.pop('parameters')
cc.pop('shocks')
cc.pop('covariances')
steady_state = cc
parameters_values = '[{}]'.format( str.join(', ', [str(v) for v in calib['parameters']]) )
funs_text = "functions = Dict{String, Function}()\n"
for fun_name in recipe['equation_type']:
funs_text += 'functions["{0}"] = {0}\n'.format(fun_name)
ss_text = "calibration = Dict{String, Any}()\n"
for k,v in steady_state.iteritems():
ss_text += 'calibration["{0}"] = [{1}]\n'.format( k, str.join(', ', ['{}'.format(e) for e in v] ) )
ss_text += 'calibration["parameters"] = {}\n'.format(str(parameters_values).replace('\n',' '))
ss_text += 'calibration["covariances"] = {}'.format(str(calib['covariances']).replace('\n',';'))
var_text = "symbols = Dict{String, Vector{String}}()\n"
for vn, vg in model.symbols_s.iteritems():
var_text += 'symbols["{0}"] = [{1}]\n'.format(vn, str.join(',', ['"{}"'.format(e ) for e in vg]))
full_text = '''
{function_definitions}
{funs_text}
{ss_text}
{var_text}
model = {{
"symbols" => symbols,
"functions" => functions,
"calibration" => calibration
}}
'''.format(
function_definitions = fun_text,
funs_text = funs_text,
ss_text = ss_text,
var_text = var_text,
)
return full_text
def process_output(self, recipe=None, diff=False):
from dolo.compiler.function_compiler_matlab import compile_multiargument_function
from dolo.compiler.function_compiler_matlab import compile_incidence_matrices
recipe = self.recipe
model = self.model
parms = model.symbols_s['parameters']
fun_text = ''
incidence_matrices_text = ''
try:
[lb_sym, ub_sym] = model.get_complementarities()['arbitrage']
states = model.symbols_s['states']
parameters = model.symbols_s['parameters']
txt_lb = compile_multiargument_function(lb_sym, [states], ['s'],
parameters,
fname='arbitrage_lb',
diff=diff,
default='-inf')
txt_ub = compile_multiargument_function(ub_sym, [states], ['s'],
parameters,
fname='arbitrage_ub',
diff=diff,
default='inf')
incidence_matrices_text += 'model.infos.incidence_matrices.arbitrage_lb = ' + compile_incidence_matrices(
lb_sym, [states]) + '\n'
incidence_matrices_text += 'model.infos.incidence_matrices.arbitrage_ub = ' + compile_incidence_matrices(
ub_sym, [states]) + '\n'
there_are_complementarities = True
except Exception as e:
there_are_complementarities = False
print(e)
for eqg in self.model.equations_groups:
args = []
is_a_definition = 'definition' in recipe['equation_type'][eqg]
if is_a_definition:
arg_specs = recipe['equation_type'][eqg]['rhs']
else:
arg_specs = recipe['equation_type'][eqg]
arg_names = []
for syms in arg_specs:
[sgn, time] = syms
args.append([
s(time) for s in model.symbols_s[sgn]
if sgn not in ('parameters', )
])
if time == 1:
stime = '_f'
elif time == -1:
stime = '_p'
else:
stime = ''
arg_names.append(sgn + stime)
equations = self.model.equations_groups[eqg]
if is_a_definition:
from dolo.compiler.common import solve_recursive_block
equations = solve_recursive_block(equations)
equations = [eq.rhs for eq in equations]
else:
equations = [eq.gap for eq in equations]
txt = compile_multiargument_function(equations,
args,
arg_names,
parms,
fname=eqg,
diff=diff)
fun_text += txt
txt = compile_incidence_matrices(equations, args)
incidence_matrices_text += 'model.infos.incidence_matrices.' + eqg + ' = ' + txt + '\n'
# the following part only makes sense for fga models
calib = model.calibration
cc = calib.copy()
cc.pop('parameters')
cc.pop('shocks')
cc.pop('covariances')
steady_state = cc
parameters_values = calib['parameters']
if 'covariances' in calib:
sigma_calib = 'calibration.sigma = {};\n'.format(
str(calib['covariances']).replace('\n', ';'))
else:
sigma_calib = {}
funs_text = "functions = struct;\n"
for fun_name in recipe['equation_type']:
funs_text += 'functions.{0} = @{0};\n'.format(fun_name)
ss_text = "calibration = struct;\n"
for k, v in steady_state.iteritems():
ss_text += 'calibration.{0} = {1};\n'.format(
k,
str(v).replace('\n', ' '))
import numpy
numpy.set_printoptions(threshold=1E6)
ss_text += 'calibration.parameters = {0};\n'.format(
str(parameters_values).replace('\n', ' '))
ss_text += sigma_calib
var_text = "symbols = struct;\n"
for vn, vg in model.symbols_s.iteritems():
var_text += 'symbols.{0} = {{{1}}};\n'.format(
vn, str.join(',', ["'{}'".format(e) for e in vg]))
if there_are_complementarities:
funs_text += """
functions.arbitrage_lb = @arbitrage_lb;
functions.arbitrage_ub = @arbitrage_ub;
"""
fun_text += txt_lb
fun_text += txt_ub
full_text = '''function model = {model_name}()
{var_text}
{calib_text}
{funs_text}
model = struct;
model.symbols = symbols;
model.functions = functions;
model.calibration = calibration;
{incidence_matrices_text}
end
{function_definitions}'''.format(
model_name=model.name,
function_definitions=fun_text,
funs_text=funs_text,
incidence_matrices_text=incidence_matrices_text,
calib_text=ss_text,
var_text=var_text,
)
return full_text
def validate(model, recipe):
# if isinstance(recipe, str):
# validate(model, recipes[recipe])
# return
for vg in model["variables_groups"]:
assert vg in recipe["variable_type"]
for eqg in model["equations_groups"]:
assert eqg in recipe["equation_type"]
eq_recipe = recipe["equation_type"][eqg]
if isinstance(eq_recipe, list):
eq_recipe = {"definition": False, "lhs": recipe["equation_type"][eqg], "rhs": recipe["equation_type"][eqg]}
if eq_recipe["definition"]:
lhs_symbols = tuple([eq.lhs for eq in model["equations_groups"][eqg]])
lhs_type = eq_recipe["lhs"][0][0]
correct_symbols = tuple(model["variables_groups"][lhs_type])
if lhs_symbols != correct_symbols:
raise (
Exception(
"""
Blocks of type "{0}" must list variables of type "{1}" in the declaration order.
Declaration order : {2}
Definition order : {3}""".format(
eqg, lhs_type, correct_symbols, lhs_symbols
)
)
)
equations = model["equations_groups"][eqg]
if eq_recipe.get("definition"):
from dolo.compiler.common import solve_recursive_block
try:
temp = solve_recursive_block(equations)
except:
raise Exception('\n The equation group "{}" cannot be solved recursively.'.format(eqg))
for side in ("lhs", "rhs"):
allowed_symbols = []
for syms in eq_recipe[side]:
[sgn, time] = syms
if syms[0] == "shocks":
allowed_symbols += [s(time) for s in model["shocks_ordering"]]
else:
allowed_symbols += [s(time) for s in model["variables_groups"][sgn]]
if eq_recipe.get("definition") and side == "rhs":
allowed_symbols += [eq.lhs for eq in equations]
# by default recursive blocs are allowed
allowed_symbols += model["parameters_ordering"]
allowed_symbols += model["parameters_ordering"]
for eq in equations:
expr = eq.lhs if side == "lhs" else eq.rhs
for a in expr.atoms():
if isinstance(a, (TSymbol, Parameter)):
if not a in allowed_symbols:
raise Exception("Unexpected symbol {0} in equation \n{1}".format(a, eq))
def process_output(self, recipe=None, diff=False):
recipe = self.recipe
model = self.model
parms = model['parameters_ordering']
fun_text = ''
for eqg in self.model['equations_groups']:
args = []
is_a_definition = 'definition' in recipe['equation_type'][eqg]
if is_a_definition:
arg_specs = recipe['equation_type'][eqg]['rhs']
else:
arg_specs = recipe['equation_type'][eqg]
arg_names = []
for syms in arg_specs:
[sgn,time] = syms
if syms[0] == 'shocks':
args.append( [ s(time) for s in model['shocks_ordering'] ] )
else:
args.append( [ s(time) for s in model['variables_groups'][sgn] ] )
if time == 1:
stime = '_f'
elif time == -1:
stime = '_p'
else:
stime = ''
arg_names.append( sgn + stime)
equations = self.model['equations_groups'][eqg]
if is_a_definition:
from dolo.compiler.common import solve_recursive_block
equations = solve_recursive_block(equations)
equations = [eq.rhs for eq in equations]
else:
equations = [eq.gap for eq in equations]
from dolo.compiler.function_compiler_matlab import compile_multiargument_function
txt = compile_multiargument_function(equations, args, arg_names, parms, fname = eqg, diff=diff)
fun_text += txt
# the following part only makes sense for fga models
calib = model.calibration
steady_state = calib['steady_state']
parameters_values = calib['parameters']
if 'sigma' in calib:
sigma_calib = 'calibration.sigma = {};\n'.format( str(calib['sigma']).replace('\n',';') )
else:
sigma_calib = {}
funs_text = "functions = struct;\n"
for fun_name in recipe['equation_type']:
funs_text += 'functions.{0} = @{0};\n'.format(fun_name)
ss_text = "steady_state = struct;\n"
for k,v in steady_state.iteritems():
ss_text += 'steady_state.{0} = {1};\n'.format( k, str(v) )
var_text = "symbols = struct;\n"
for vn, vg in model['variables_groups'].iteritems():
var_text += 'symbols.{0} = {{{1}}};\n'.format(vn, str.join(',', ["'{}'".format(e ) for e in vg]))
var_text += 'symbols.parameters = {{{}}};\n'.format(str.join(',', ["'{}'".format(e ) for e in model['parameters_ordering']]))
var_text += 'symbols.shocks = {{{}}};\n'.format(str.join(',', ["'{}'".format(e ) for e in model['shocks_ordering']]))
full_text = '''
function [model] = get_model()
{ss_text}
{var_text}
calibration = struct;
calibration.steady_state = steady_state;
calibration.parameters = {params};
{sigma_calib}
{funs_text}
model = struct;
model.symbols = symbols;
model.functions = functions;
model.calibration = calibration;
end
{function_definitions}
'''.format(
function_definitions = fun_text,
funs_text = funs_text,
ss_text = ss_text,
sigma_calib = sigma_calib,
var_text = var_text,
params = str(parameters_values)
)
return full_text
def process_output(self, recipe=None, diff=False):
from dolo.compiler.function_compiler_matlab import compile_multiargument_function
from dolo.compiler.function_compiler_matlab import compile_incidence_matrices
recipe = self.recipe
model = self.model
parms = model.symbols_s['parameters']
fun_text = ''
incidence_matrices_text = ''
try:
[lb_sym, ub_sym] = model.get_complementarities()['arbitrage']
states = model.symbols_s['states']
parameters = model.symbols_s['parameters']
txt_lb = compile_multiargument_function(lb_sym, [states], ['s'], parameters, fname = 'arbitrage_lb', diff=diff, default='-inf')
txt_ub = compile_multiargument_function(ub_sym, [states], ['s'], parameters, fname = 'arbitrage_ub', diff=diff, default='inf')
incidence_matrices_text += 'model.infos.incidence_matrices.arbitrage_lb = ' + compile_incidence_matrices(lb_sym, [states]) + '\n'
incidence_matrices_text += 'model.infos.incidence_matrices.arbitrage_ub = ' + compile_incidence_matrices(ub_sym, [states]) + '\n'
there_are_complementarities = True
except Exception as e:
there_are_complementarities = False
print(e)
for eqg in self.model.equations_groups:
args = []
is_a_definition = 'definition' in recipe['equation_type'][eqg]
if is_a_definition:
arg_specs = recipe['equation_type'][eqg]['rhs']
else:
arg_specs = recipe['equation_type'][eqg]
arg_names = []
for syms in arg_specs:
[sgn,time] = syms
args.append( [ s(time) for s in model.symbols_s[sgn] if sgn not in ('parameters',) ] )
if time == 1:
stime = '_f'
elif time == -1:
stime = '_p'
else:
stime = ''
arg_names.append( sgn + stime)
equations = self.model.equations_groups[eqg]
if is_a_definition:
from dolo.compiler.common import solve_recursive_block
equations = solve_recursive_block(equations)
equations = [eq.rhs for eq in equations]
else:
equations = [eq.gap for eq in equations]
txt = compile_multiargument_function(equations, args, arg_names, parms, fname = eqg, diff=diff)
fun_text += txt
txt = compile_incidence_matrices(equations, args)
incidence_matrices_text += 'model.infos.incidence_matrices.' + eqg + ' = ' + txt + '\n'
# the following part only makes sense for fga models
calib = model.calibration
cc = calib.copy()
cc.pop('parameters')
cc.pop('shocks')
cc.pop('covariances')
steady_state = cc
parameters_values = calib['parameters']
if 'covariances' in calib:
sigma_calib = 'calibration.sigma = {};\n'.format( str(calib['covariances']).replace('\n',';') )
else:
sigma_calib = {}
funs_text = "functions = struct;\n"
for fun_name in recipe['equation_type']:
funs_text += 'functions.{0} = @{0};\n'.format(fun_name)
ss_text = "calibration = struct;\n"
for k,v in steady_state.iteritems():
ss_text += 'calibration.{0} = {1};\n'.format( k, str(v).replace('\n',' ') )
import numpy
numpy.set_printoptions(threshold=1E6)
ss_text += 'calibration.parameters = {0};\n'.format(str(parameters_values).replace('\n',' '))
ss_text += sigma_calib
var_text = "symbols = struct;\n"
for vn, vg in model.symbols_s.iteritems():
var_text += 'symbols.{0} = {{{1}}};\n'.format(vn, str.join(',', ["'{}'".format(e ) for e in vg]))
if there_are_complementarities:
funs_text += """
functions.arbitrage_lb = @arbitrage_lb;
functions.arbitrage_ub = @arbitrage_ub;
"""
fun_text += txt_lb
fun_text += txt_ub
full_text = '''function model = {model_name}()
{var_text}
{calib_text}
{funs_text}
model = struct;
model.symbols = symbols;
model.functions = functions;
model.calibration = calibration;
{incidence_matrices_text}
end
{function_definitions}'''.format(
model_name = model.name,
function_definitions = fun_text,
funs_text = funs_text,
incidence_matrices_text = incidence_matrices_text,
calib_text = ss_text,
var_text = var_text,
)
return full_text
def validate(model, recipe):
# if isinstance(recipe, str):
# validate(model, recipes[recipe])
# return
for vg in model.symbols_s:
if not vg in ('parameters','shocks'):
assert( vg in recipe['variable_type'])
for eqg in model.equations_groups:
assert( eqg in recipe['equation_type'])
eq_recipe = recipe['equation_type'][eqg]
if isinstance(eq_recipe, list):
eq_recipe = {'definition': False, 'lhs': recipe['equation_type'][eqg], 'rhs': recipe['equation_type'][eqg]}
if eq_recipe['definition']:
lhs_symbols = tuple( [eq.lhs for eq in model.equations_groups[eqg]] )
lhs_type = eq_recipe['lhs'][0][0]
correct_symbols = tuple( model.symbols_s[lhs_type] )
if lhs_symbols != correct_symbols:
raise(Exception('''
Blocks of type "{0}" must list variables of type "{1}" in the declaration order.
Declaration order : {2}
Definition order : {3}'''.format(eqg, lhs_type, correct_symbols, lhs_symbols)))
equations = model.equations_groups[eqg]
if eq_recipe.get('definition'):
from dolo.compiler.common import solve_recursive_block
try:
temp = solve_recursive_block(equations)
except:
raise Exception('\n The equation group "{}" cannot be solved recursively.'.format(eqg) )
for side in ('lhs', 'rhs'):
allowed_symbols = []
for syms in eq_recipe[side]:
[sgn,time] = syms
if syms[0] == 'shocks':
allowed_symbols += [ s(time) for s in model.symbols_s['shocks'] ]
else:
allowed_symbols += [ s(time) for s in model.symbols_s[sgn] ]
if eq_recipe.get('definition') and side == 'rhs':
allowed_symbols += [ eq.lhs for eq in equations ]
# by default recursive blocs are allowed
allowed_symbols += model.symbols_s['parameters']
allowed_symbols += model.symbols_s['parameters']
for eq in equations:
expr = eq.lhs if side=='lhs' else eq.rhs
for a in expr.atoms():
if isinstance(a, (TSymbol, Parameter)):
if not a in allowed_symbols:
raise Exception('Unexpected symbol {0} in equation \n{1}'.format(a, eq))
def process_output(self, recipe=None):
recipe = self.recipe
model = self.model
parms = model['parameters_ordering']
fun_text = ''
for eqg in self.model['equations_groups']:
args = []
is_a_definition = 'definition' in recipe['equation_type'][eqg]
if is_a_definition:
arg_specs = recipe['equation_type'][eqg]['rhs']
else:
arg_specs = recipe['equation_type'][eqg]
arg_names = []
for syms in arg_specs:
[sgn,time] = syms
if syms[0] == 'shocks':
args.append( [ s(time) for s in model['shocks_ordering'] ] )
else:
args.append( [ s(time) for s in model['variables_groups'][sgn] ] )
if time == 1:
stime = '_f'
elif time == -1:
stime = '_p'
else:
stime = ''
arg_names.append( sgn + stime)
equations = self.model['equations_groups'][eqg]
if is_a_definition:
from dolo.compiler.common import solve_recursive_block
equations = solve_recursive_block(equations)
equations = [eq.rhs for eq in equations]
else:
equations = [eq.gap for eq in equations]
from dolo.compiler.function_compiler_julia import compile_multiargument_function
txt = compile_multiargument_function(equations, args, arg_names, parms, fname = eqg)
fun_text += txt
# the following part only makes sense for fga models
calib = model.calibration
steady_state = calib['steady_state']
parameters_values = calib['parameters']
funs_text = "functions = {\n"
for fun_name in recipe['equation_type']:
funs_text += '\t"{0}" => {0},\n'.format(fun_name)
funs_text += '}'
ss_text = "steady_state = {\n"
for k,v in steady_state.iteritems():
ss_text += '\t"{0}" => {1},\n'.format( k, str(v) )
ss_text += '}'
var_text = "symbols = {\n"
for vn, vg in model['variables_groups'].iteritems():
var_text += '\t"{0}" => [{1}],\n'.format(vn, str.join(',', ['"{}"'.format(e ) for e in vg]))
var_text += '\t"parameters" => [{}],\n'.format(str.join(',', ['"{}"'.format(e ) for e in model['parameters_ordering']]))
var_text += '\t"shocks" => [{}]\n'.format(str.join(',', ['"{}"'.format(e ) for e in model['shocks_ordering']]))
var_text += '}'
full_text = '''
{function_definitions}
{funs_text}
{ss_text}
{var_text}
calibration = {{
"steady_state" => steady_state,
"parameters" => {params}
}}
model = {{
"symbols" => symbols,
"functions" => functions,
"calibration" => calibration
}}
'''.format(
function_definitions = fun_text,
funs_text = funs_text,
ss_text = ss_text,
var_text = var_text,
params = str(parameters_values)
)
return full_text
def __create_functions__(self, compiler, order='rows'):
recipe = self.recipe
model = self.model
parms = model.symbols_s['parameters']
if compiler == 'numexpr':
from dolo.compiler.function_compiler_numexpr import compile_multiargument_function
elif compiler == 'theano':
from dolo.compiler.function_compiler_theano import compile_multiargument_function
elif compiler == 'numba':
from dolo.compiler.function_compiler_numba import compile_multiargument_function
elif compiler == 'numba_gpu':
from dolo.compiler.function_compiler_numba_gpu import compile_multiargument_function
else:
from dolo.compiler.function_compiler import compile_multiargument_function
functions = {}
for eqg in self.model.equations_groups:
args = []
is_a_definition = 'definition' in recipe['equation_type'][eqg]
if is_a_definition:
arg_specs = recipe['equation_type'][eqg]['rhs']
else:
arg_specs = recipe['equation_type'][eqg]
arg_names = []
for syms in arg_specs:
[sgn,time] = syms
if syms[0] == 'shocks':
args.append( [ s(time) for s in model.symbols_s['shocks'] ] )
else:
args.append( [ s(time) for s in model.symbols_s[sgn] ] )
if time == 1:
stime = '_f'
elif time == -1:
stime = '_p'
else:
stime = ''
arg_names.append( sgn + stime)
equations = self.model.equations_groups[eqg]
if is_a_definition:
from dolo.compiler.common import solve_recursive_block
equations = solve_recursive_block(equations)
equations = [eq.rhs for eq in equations]
else:
equations = [eq.gap for eq in equations]
functions[eqg] = compile_multiargument_function(equations, args, arg_names, parms, fname = eqg, order=order)
self.__update_calibration__()
from collections import OrderedDict
l = [ (vg, [str(s) for s in model.symbols_s[vg]] ) for vg in (recipe['variable_type'] + ['shocks','parameters']) ]
symbols = OrderedDict( l )
self.symbols = symbols
self.functions = functions
def __create_functions__(self, compiler, order='rows'):
recipe = self.recipe
model = self.model
parms = model.symbols_s['parameters']
if compiler == 'numexpr':
from dolo.compiler.function_compiler_numexpr import compile_multiargument_function
elif compiler == 'theano':
from dolo.compiler.function_compiler_theano import compile_multiargument_function
elif compiler == 'numba':
from dolo.compiler.function_compiler_numba import compile_multiargument_function
elif compiler == 'numba_gpu':
from dolo.compiler.function_compiler_numba_gpu import compile_multiargument_function
else:
from dolo.compiler.function_compiler import compile_multiargument_function
functions = {}
for eqg in self.model.equations_groups:
args = []
is_a_definition = 'definition' in recipe['equation_type'][eqg]
if is_a_definition:
arg_specs = recipe['equation_type'][eqg]['rhs']
else:
arg_specs = recipe['equation_type'][eqg]
arg_names = []
for syms in arg_specs:
[sgn, time] = syms
if syms[0] == 'shocks':
args.append([s(time) for s in model.symbols_s['shocks']])
else:
args.append([s(time) for s in model.symbols_s[sgn]])
if time == 1:
stime = '_f'
elif time == -1:
stime = '_p'
else:
stime = ''
arg_names.append(sgn + stime)
equations = self.model.equations_groups[eqg]
if is_a_definition:
from dolo.compiler.common import solve_recursive_block
equations = solve_recursive_block(equations)
equations = [eq.rhs for eq in equations]
else:
equations = [eq.gap for eq in equations]
functions[eqg] = compile_multiargument_function(equations,
args,
arg_names,
parms,
fname=eqg,
order=order)
self.__update_calibration__()
from collections import OrderedDict
l = [(vg, [str(s) for s in model.symbols_s[vg]])
for vg in (recipe['variable_type'] + ['shocks', 'parameters'])]
symbols = OrderedDict(l)
self.symbols = symbols
self.functions = functions
def __create_functions__(self, compiler):
recipe = self.recipe
model = self.model
parms = model['parameters_ordering']
functions = {}
for eqg in self.model['equations_groups']:
args = []
is_a_definition = 'definition' in recipe['equation_type'][eqg]
if is_a_definition:
arg_specs = recipe['equation_type'][eqg]['rhs']
else:
arg_specs = recipe['equation_type'][eqg]
arg_names = []
for syms in arg_specs:
[sgn,time] = syms
if syms[0] == 'shocks':
args.append( [ s(time) for s in model['shocks_ordering'] ] )
else:
args.append( [ s(time) for s in model['variables_groups'][sgn] ] )
if time == 1:
stime = '_f'
elif time == -1:
stime = '_p'
else:
stime = ''
arg_names.append( sgn + stime)
equations = self.model['equations_groups'][eqg]
if is_a_definition:
from dolo.compiler.common import solve_recursive_block
equations = solve_recursive_block(equations)
equations = [eq.rhs for eq in equations]
else:
equations = [eq.gap for eq in equations]
if compiler == 'numexpr':
from dolo.compiler.function_compiler_numexpr import compile_multiargument_function
elif compiler == 'theano':
from dolo.compiler.function_compiler_theano import compile_multiargument_function
else:
from dolo.compiler.function_compiler import compile_multiargument_function
functions[eqg] = compile_multiargument_function(equations, args, arg_names, parms, fname = eqg)
calibration = model.calibration
import numpy
from collections import OrderedDict
for k,v in calibration.iteritems():
if isinstance(v, OrderedDict):
for l in v:
v[l] = numpy.array(v[l], dtype=numpy.double)
else:
calibration[k] = numpy.array(calibration[k], dtype=numpy.double)
symbols = {}
for vn, vg in model['variables_groups'].iteritems():
symbols[vn] = [str(v) for v in vg]
symbols['shocks'] = [str(v) for v in model.shocks]
symbols['parameters'] = [str(v) for v in model.parameters]
self.calibration = calibration
self.symbols = symbols
self.functions = functions
