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]