def __compile_functions__(self): from dolang.function_compiler import make_method_from_factory from dolang.vectorize import standard_function from dolo.compiler.factories import get_factory functions = {} original_functions = {} original_gufunctions = {} funnames = [*self.equations.keys()] + ['auxiliary'] import dolo.config debug = dolo.config.debug for funname in funnames: fff = get_factory(self, funname) fun, gufun = make_method_from_factory(fff, vectorize=True, debug=debug) n_output = len(fff.content) functions[funname] = standard_function(gufun, n_output) original_gufunctions[funname] = gufun # basic gufun function original_functions[funname] = fun # basic numba fun self.__original_functions__ = original_functions self.__original_gufunctions__ = original_gufunctions self.__functions__ = functions
def __compile_functions__(self): from dolang.function_compiler import make_method_from_factory from dolang.vectorize import standard_function from dolo.compiler.factories import get_factory from .misc import LoosyDict equivalent_function_names = { 'equilibrium': 'arbitrage', 'optimality': 'arbitrage' } functions = LoosyDict(equivalences=equivalent_function_names) original_functions = {} original_gufunctions = {} funnames = [*self.equations.keys()] + ['auxiliary'] import dolo.config debug = dolo.config.debug for funname in funnames: fff = get_factory(self, funname) fun, gufun = make_method_from_factory(fff, vectorize=True, debug=debug) n_output = len(fff.content) functions[funname] = standard_function(gufun, n_output) original_gufunctions[funname] = gufun # basic gufun function original_functions[funname] = fun # basic numba fun self.__original_functions__ = original_functions self.__original_gufunctions__ = original_gufunctions self.__functions__ = functions
def __compile_functions__(self): from dolang.function_compiler import make_method_from_factory from dolang.vectorize import standard_function from dolo.compiler.factories import get_factory functions = {} original_functions = {} original_gufunctions = {} funnames = [*self.equations.keys()] + ['auxiliary'] import dolo.config debug = dolo.config.debug for funname in funnames: fff = get_factory(self, funname) fun, gufun = make_method_from_factory( fff, vectorize=True, debug=debug) n_output = len(fff.content) functions[funname] = standard_function(gufun, n_output) original_gufunctions[funname] = gufun # basic gufun function original_functions[funname] = fun # basic numba fun self.__original_functions__ = original_functions self.__original_gufunctions__ = original_gufunctions self.functions = functions
def ℰ(self): if self.__equilibrium__ is None: if self.features["with-aggregate-states"]: arguments_ = { "e": [(e, 0) for e in self.model.symbols["exogenous"]], "s": [(e, 0) for e in self.model.symbols["states"]], "x": [(e, 0) for e in self.model.symbols["controls"]], "m": [(e, 0) for e in self.symbols["exogenous"]], "S": [(e, 0) for e in self.symbols["states"]], "X": [(e, 0) for e in self.symbols["aggregate"]], "m_1": [(e, 1) for e in self.symbols["exogenous"]], "S_1": [(e, 1) for e in self.symbols["states"]], "X_1": [(e, 1) for e in self.symbols["aggregate"]], "p": self.symbols["parameters"], } else: arguments_ = { "e": [(e, 0) for e in self.model.symbols["exogenous"]], "s": [(e, 0) for e in self.model.symbols["states"]], "x": [(e, 0) for e in self.model.symbols["controls"]], "m": [(e, 0) for e in self.symbols["exogenous"]], "X": [(e, 0) for e in self.symbols["aggregate"]], "m_1": [(e, 1) for e in self.symbols["exogenous"]], "X_1": [(e, 1) for e in self.symbols["aggregate"]], "p": self.symbols["parameters"], } vars = sum([[e[0] for e in h] for h in [*arguments_.values()][:-1]], []) arguments = { k: [dolang.symbolic.stringify_symbol(e) for e in v] for k, v in arguments_.items() } preamble = {} # for now from dolang.symbolic import sanitize, stringify eqs = parse_string(self.data["equilibrium"], start="equation_block") eqs = sanitize(eqs, variables=vars) eqs = stringify(eqs) content = {} for i, eq in enumerate(eqs.children): lhs, rhs = eq.children content[f"eq_{i}"] = "({1})-({0})".format( str_expression(lhs), str_expression(rhs)) fff = FlatFunctionFactory(preamble, content, arguments, "equilibrium") _, gufun = dolang.function_compiler.make_method_from_factory( fff, debug=self.debug) from dolang.vectorize import standard_function self.__equilibrium__ = standard_function(gufun, len(content)) return self.__equilibrium__
def projection(self): # , m: 'n_e', y: "n_y", p: "n_p"): # TODO: # behaves in a very misleading way if wrong number of argument is supplied # if no aggregate states, projection(m,x) (instead of projection(m,x,p)) returns zeros if self.__projection__ is None: if self.features["with-aggregate-states"]: arguments_ = { "m": [(e, 0) for e in self.symbols["exogenous"]], "S": [(e, 0) for e in self.symbols["states"]], "X": [(e, 0) for e in self.symbols["aggregate"]], "p": self.symbols["parameters"], } else: arguments_ = { "m": [(e, 0) for e in self.symbols["exogenous"]], "X": [(e, 0) for e in self.symbols["aggregate"]], "p": self.symbols["parameters"], } vars = sum([[e[0] for e in h] for h in [*arguments_.values()][:-1]], []) arguments = { k: [dolang.symbolic.stringify_symbol(e) for e in v] for k, v in arguments_.items() } preamble = {} # for now from dolang.symbolic import sanitize, stringify eqs = parse_string(self.data["projection"], start="assignment_block") eqs = sanitize(eqs, variables=vars) eqs = stringify(eqs) content = {} for eq in eqs.children: lhs, rhs = eq.children content[str_expression(lhs)] = str_expression(rhs) fff = FlatFunctionFactory(preamble, content, arguments, "equilibrium") _, gufun = dolang.function_compiler.make_method_from_factory( fff, debug=self.debug) from dolang.vectorize import standard_function self.__projection__ = standard_function(gufun, len(content)) return self.__projection__
def 𝒢(self): if (self.__transition__ is None) and self.features["with-aggregate-states"]: arguments_ = { "m_m1": [(e, -1) for e in self.symbols["exogenous"]], "S_m1": [(e, -1) for e in self.symbols["states"]], "X_m1": [(e, -1) for e in self.symbols["aggregate"]], "m": [(e, 0) for e in self.symbols["exogenous"]], "p": self.symbols["parameters"], } vars = sum([[e[0] for e in h] for h in [*arguments_.values()][:-1]], []) arguments = { k: [dolang.symbolic.stringify_symbol(e) for e in v] for k, v in arguments_.items() } preamble = {} # for now from dolang.symbolic import ( sanitize, parse_string, str_expression, stringify, ) eqs = parse_string(self.data["transition"], start="assignment_block") eqs = sanitize(eqs, variables=vars) eqs = stringify(eqs) content = {} for i, eq in enumerate(eqs.children): lhs, rhs = eq.children content[str_expression(lhs)] = str_expression(rhs) from dolang.factory import FlatFunctionFactory fff = FlatFunctionFactory(preamble, content, arguments, "transition") _, gufun = dolang.function_compiler.make_method_from_factory( fff, debug=self.debug) from dolang.vectorize import standard_function self.__transition__ = standard_function(gufun, len(content)) return self.__transition__
def projection(self): #, m: 'n_e', y: "n_y", p: "n_p"): if self.__projection__ is None: arguments_ = { # 'e': [(e,0) for e in self.model.symbols['exogenous']], # 's': [(e,0) for e in self.model.symbols['states']], # 'x': [(e,0) for e in self.model.symbols['controls']], 'm': [(e, 0) for e in self.symbols['exogenous']], 'y': [(e, 0) for e in self.symbols['aggregate']], 'p': self.symbols['parameters'] } vars = sum([[e[0] for e in h] for h in [*arguments_.values()][:-1]], []) arguments = { k: [dolang.symbolic.stringify_symbol(e) for e in v] for k, v in arguments_.items() } preamble = {} # for now projdefs = self.data.get('projection', {}) pkeys = [*projdefs.keys()] n_p = len(pkeys) equations = [ projdefs[v] for v in self.model.symbols['exogenous'][:n_p] ] equations = [ dolang.stringify(eq, variables=vars) for eq in equations ] content = {f'{pkeys[i]}_0': eq for i, eq in enumerate(equations)} fff = FlatFunctionFactory(preamble, content, arguments, 'equilibrium') fun = dolang.function_compiler.make_method_from_factory( fff, debug=self.debug) from dolang.vectorize import standard_function self.__projection__ = standard_function(fun[1], len(equations)) return self.__projection__
def ℰ(self): if self.__equilibrium__ is None: arguments_ = { 'e': [(e, 0) for e in self.model.symbols['exogenous']], 's': [(e, 0) for e in self.model.symbols['states']], 'x': [(e, 0) for e in self.model.symbols['controls']], 'm': [(e, 0) for e in self.symbols['exogenous']], 'y': [(e, 0) for e in self.symbols['aggregate']], 'p': self.symbols['parameters'] } vars = sum([[e[0] for e in h] for h in [*arguments_.values()][:-1]], []) arguments = { k: [dolang.symbolic.stringify_symbol(e) for e in v] for k, v in arguments_.items() } preamble = {} # for now equations = [ ("{}-({})".format(*(str(eq).split('='))) if '=' in eq else eq) for eq in self.data['equilibrium'] ] equations = [ dolang.stringify(eq, variables=vars) for eq in equations ] content = {f'eq_{i}': eq for i, eq in enumerate(equations)} fff = FlatFunctionFactory(preamble, content, arguments, 'equilibrium') fun = dolang.function_compiler.make_method_from_factory( fff, debug=self.debug) from dolang.vectorize import standard_function self.__equilibrium__ = standard_function(fun[1], len(equations)) return self.__equilibrium__
return out # now the functions transition_gu and arbitrage_gu # are generelized ufuncs, which implement numpy-style # broadcasting transition_gu(m, s, x, m[None, :].repeat(10, axis=0), p) # we use another convenience function to get a function which # is able to compute derivatives # I don't like this way to proceed, this should be rewritten # currently it is only used for perturbations anyway. from dolang.vectorize import standard_function transition = standard_function(transition_gu, 2) arbitrage = standard_function(arbitrage_gu, 2) [g, g_m, g_s, g_x, g_m] = transition(m, s, x, m, p, diff=True) functions = {'transition': transition, 'arbitrage': arbitrage} ### ### Exogenous process ### from dolo.numeric.processes_iid import UNormal exogenous = UNormal(σ=0.001) ### ### Discretized grid for endogenous states