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]