def model_to_fg(model, solve_systems=False, compiler='numpy', order=None):
sgm = simple_global_representation(model, solve_systems=solve_systems)
controls = sgm['controls']
states = sgm['states']
parameters = sgm['parameters']
shocks = sgm['shocks']
f_eqs = sgm['f_eqs']
g_eqs = sgm['g_eqs']
controls_f = [c(1) for c in controls]
states_f = [c(1) for c in states]
controls_p = [c(-1) for c in controls]
states_p = [c(-1) for c in states]
shocks_f = [c(1) for c in shocks]
args_g = [states_p, controls_p, shocks]
args_f = [states, controls, states_f, controls_f, shocks_f]
if order is not None:
from dolo.compiler.function_compiler import compile_function
g_fun = compile_function(g_eqs, sum(args_g, []), parameters, order)
f_fun = compile_function(
f_eqs, sum([states, controls, states_f, controls_f], []),
parameters, order)
return [g_fun, f_fun]
keep_auxiliary = 'a_eqs' in sgm
if keep_auxiliary:
# auxiliaries = sgm['auxiliaries']
a_eqs = sgm['a_eqs']
args_a = [states, controls]
if compiler == 'numpy':
from dolo.compiler.function_compiler import compile_multiargument_function
elif compiler == 'theano':
from dolo.compiler.function_compiler_theano import compile_multiargument_function
elif compiler == 'numexpr':
from dolo.compiler.function_compiler_numexpr 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:
raise Exception('Unknown compiler type : {}'.format(compiler))
g = compile_multiargument_function(g_eqs, args_g, ['s', 'x', 'e'],
parameters, 'g')
f = compile_multiargument_function(f_eqs, args_f,
['s', 'x', 'snext', 'xnext', 'e'],
parameters, 'f')
if keep_auxiliary:
a = compile_multiargument_function(a_eqs, args_a, ['s', 'x'],
parameters, 'a')
return [f, g, a]
else:
return [f, g]
def model_to_fg(model, solve_systems=False, compiler='numpy', order=None):
sgm = simple_global_representation(model, solve_systems=solve_systems)
controls = sgm['controls']
states = sgm['states']
parameters = sgm['parameters']
shocks = sgm['shocks']
f_eqs = sgm['f_eqs']
g_eqs = sgm['g_eqs']
controls_f = [c(1) for c in controls]
states_f = [c(1) for c in states]
controls_p = [c(-1) for c in controls]
states_p = [c(-1) for c in states]
shocks_f = [c(1) for c in shocks]
args_g = [states_p, controls_p, shocks]
args_f = [states, controls, states_f, controls_f, shocks_f]
if order is not None:
from dolo.compiler.function_compiler import compile_function
g_fun = compile_function( g_eqs, sum(args_g, []), parameters, order )
f_fun = compile_function( f_eqs, sum([states, controls, states_f, controls_f], []), parameters, order )
return [g_fun, f_fun]
keep_auxiliary = 'a_eqs' in sgm
if keep_auxiliary:
# auxiliaries = sgm['auxiliaries']
a_eqs = sgm['a_eqs']
args_a = [states, controls]
if compiler=='numpy':
from dolo.compiler.function_compiler import compile_multiargument_function
elif compiler == 'theano':
from dolo.compiler.function_compiler_theano import compile_multiargument_function
elif compiler == 'numexpr':
from dolo.compiler.function_compiler_numexpr 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:
raise Exception('Unknown compiler type : {}'.format(compiler))
g = compile_multiargument_function(g_eqs, args_g, ['s','x','e'], parameters, 'g' )
f = compile_multiargument_function(f_eqs, args_f, ['s','x','snext','xnext','e'], parameters, 'f' )
if keep_auxiliary:
a = compile_multiargument_function(a_eqs, args_a, ['s','x'], parameters, 'a' )
return [f,g,a]
else:
return [f,g]
def __init__(self, model):
self.model = model
var_g = model['variables_groups']
controls = var_g['controls']
states = var_g['states']
auxiliary = var_g['auxiliary']
expectations = var_g['expectations']
parameters = model.parameters
shocks = model.shocks
f_eqs = model['equations_groups']['arbitrage']
a_eqs = model['equations_groups']['auxiliary']
g_eqs = model['equations_groups']['transition']
h_eqs = model['equations_groups']['expectation']
f_eqs = [eq.gap for eq in f_eqs]
a_eqs = [eq.rhs for eq in a_eqs]
g_eqs = [eq.rhs for eq in g_eqs]
h_eqs = [eq.rhs for eq in h_eqs]
controls_f = [c(1) for c in controls]
states_f = [c(1) for c in states]
controls_p = [c(-1) for c in controls]
states_p = [c(-1) for c in states]
shocks_f = [c(1) for c in shocks]
auxiliary_p = [c(-1) for c in auxiliary]
auxiliary_f = [c(1) for c in auxiliary]
args_g = [states_p, controls_p, auxiliary_p, shocks]
args_f = [states, controls, auxiliary, expectations]
args_a = [states, controls]
args_h = [states_f, controls_f, auxiliary_f]
from dolo.compiler.function_compiler import compile_multiargument_function
self.__g__ = compile_multiargument_function(g_eqs, args_g, ['s','x','a','e'], parameters, 'g' )
self.__f__ = compile_multiargument_function(f_eqs, args_f, ['s','x','a','z'], parameters, 'f' )
self.__a__ = compile_multiargument_function(a_eqs, args_a, ['s','x'], parameters, 'a' )
self.__h__ = compile_multiargument_function(h_eqs, args_h, ['s','x','a'], parameters, 'h' )
def x_bounds(self):
# TODO : bounds should be compiled in __init__ (after sgm cleanup)
model = self.model
complementarities_tags = [eq.tags.get('complementarity') for eq in model['equations_groups']['arbitrage']]
import re
regex = re.compile('(.*)<=(.*)<=(.*)')
parsed = [ [model.eval_string(e) for e in regex.match(s).groups()] for s in complementarities_tags]
lower_bounds_symbolic = [p[0] for p in parsed]
controls = [p[1] for p in parsed]
upper_bounds_symbolic = [p[2] for p in parsed]
try:
controls == model['variables_groups']['controls']
except:
raise Exception("Order of complementarities does not match order of declaration of controls.")
states = model['variables_groups']['states']
parameters = model.parameters
from dolo.compiler.function_compiler import compile_multiargument_function
lb = compile_multiargument_function( lower_bounds_symbolic, [states], ['s'], parameters, fname='lb')
ub = compile_multiargument_function( upper_bounds_symbolic, [states], ['s'], parameters, fname='ub' )
return [lb,ub]
def x_bounds(self):
# TODO : bounds should be compiled in __init__ (after sgm cleanup)
model = self.model
complementarities_tags = [eq.tags.get('complementarity') for eq in model.equations_groups['arbitrage']]
import re
regex = re.compile('(.*)<=(.*)<=(.*)')
parsed = [ [model.eval_string(e) for e in regex.match(s).groups()] for s in complementarities_tags]
lower_bounds_symbolic = [p[0] for p in parsed]
controls = [p[1] for p in parsed]
upper_bounds_symbolic = [p[2] for p in parsed]
try:
controls == model.symbols_s['controls']
except:
raise Exception("Order of complementarities does not match order of declaration of controls.")
states = model.symbols_s['states']
parameters = model.parameters
from dolo.compiler.function_compiler import compile_multiargument_function
lb = compile_multiargument_function( lower_bounds_symbolic, [states], ['s'], parameters, fname='lb')
ub = compile_multiargument_function( upper_bounds_symbolic, [states], ['s'], parameters, fname='ub' )
return [lb,ub]
def model_to_fg(model, solve_systems=False, compiler='numpy', order=None):
sgm = simple_global_representation(model, solve_systems=solve_systems)
controls = sgm['controls']
states = sgm['states']
parameters = sgm['parameters']
shocks = sgm['shocks']
f_eqs = sgm['f_eqs']
g_eqs = sgm['g_eqs']
controls_f = [c(1) for c in controls]
states_f = [c(1) for c in states]
controls_p = [c(-1) for c in controls]
states_p = [c(-1) for c in states]
shocks_f = [c(1) for c in shocks]
args_g = [states_p, controls_p, shocks]
args_f = [states, controls, states_f, controls_f, shocks_f]
if order is not None:
from dolo.compiler.function_compiler import compile_function
g_fun = compile_function( g_eqs, sum(args_g, []), parameters, order )
f_fun = compile_function( f_eqs, sum([states, controls, states_f, controls_f], []), parameters, order )
return [g_fun, f_fun]
keep_auxiliary = 'a_eqs' in sgm
if keep_auxiliary:
# auxiliaries = sgm['auxiliaries']
a_eqs = sgm['a_eqs']
args_a = [states, controls]
if compiler=='numpy':
from dolo.compiler.function_compiler import compile_multiargument_function
elif compiler == 'theano':
from dolo.compiler.function_compiler_theano import compile_multiargument_function
elif compiler == 'numexpr':
from dolo.compiler.function_compiler_numexpr import compile_multiargument_function
else:
raise Exception('Unknown compiler type : {}'.format(compiler))
g = compile_multiargument_function(g_eqs, args_g, ['s','x','e'], parameters, 'g' )
f = compile_multiargument_function(f_eqs, args_f, ['s','x','snext','xnext','e'], parameters, 'f' )
if keep_auxiliary:
a = compile_multiargument_function(a_eqs, args_a, ['s','x'], parameters, 'a' )
return [f,g,a]
else:
return [f,g]
#
#def model_to_fga(model, compiler='numpy'):
#
# from dolo.misc.triangular_solver import solve_triangular_system
#
# from dolo.misc.misc import timeshift
#
# eq_g = model['equations_groups']
# v_g = model['variables_groups']
#
# f_eqs = [eq.gap for eq in eq_g['arbitrage']]
# g_eqs = [eq for eq in eq_g['transition']]
# a_eqs = [eq for eq in eq_g['auxiliary']]
#
# # auxiliaries_2 are simply replaced in all other types of equations
# a2_dict = {}
# a2_dict_g = {}
#
# if 'auxiliary_2' in eq_g:
# aux2_eqs = eq_g['auxiliary_2']
# dd = {eq.lhs: eq.rhs for eq in aux2_eqs}
# dd.update( { eq.lhs(1): timeshift(eq.rhs,1) for eq in aux2_eqs } )
# dd.update( { eq.lhs(-1): timeshift(eq.rhs,-1) for eq in aux2_eqs } )
# ds = solve_triangular_system(dd)
#
# f_eqs = [eq.subs(ds) for eq in f_eqs]
# a_eqs = [eq.subs(ds) for eq in a_eqs]
# g_eqs = [eq.subs(ds) for eq in g_eqs]
#
# controls = v_g['controls']
# auxiliaries = v_g['auxiliary']
# states = v_g['states']
#
# parameters = model.parameters
# shocks = model.shocks
#
# dd = {eq.lhs: eq.rhs for eq in g_eqs}
# ds = solve_triangular_system(dd)
# g_eqs = [ds[eq.lhs] for eq in g_eqs]
#
# dd = {eq.lhs: eq.rhs for eq in a_eqs}
# ds = solve_triangular_system(dd)
# a_eqs = [ds[eq.lhs] for eq in a_eqs]
#
#
# auxiliaries_f = [c(1) for c in auxiliaries]
# auxiliaries_p = [c(-1) for c in auxiliaries]
#
# controls_f = [c(1) for c in controls]
# states_f = [c(1) for c in states]
# controls_p = [c(-1) for c in controls]
# states_p = [c(-1) for c in states]
# shocks_f = [c(1) for c in shocks]
#
# args_g = [states_p, controls_p, auxiliaries_p, shocks]
# args_f = [states, controls, states_f, controls_f, auxiliaries, auxiliaries_f, shocks_f]
# args_a = [states, controls]
#
#
# if compiler=='numpy':
# from dolo.compiler.compiling import compile_multiargument_function
# compile_multiargument_function
# elif compiler == 'theano':
# from dolo.compiler.compiling_theano import compile_multiargument_function
# elif compiler == 'numexpr':
# from dolo.compiler.compiling_numexpr import compile_multiargument_function
#
# g = compile_multiargument_function(g_eqs, args_g, ['s','x','y','e'], parameters, 'g' )
# f = compile_multiargument_function(f_eqs, args_f, ['s','x','snext','xnext','y','ynext','e'], parameters, 'f' )
# a = compile_multiargument_function(a_eqs, args_a, ['s','x'], parameters, 'a' )
#
# return [f,a,g]
