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
