def get_exogenous(self):
if "exogenous" not in self.data:
return {}
exo = self.data['exogenous']
calibration = self.get_calibration()
from dolang.language import eval_data
exogenous = eval_data(exo, calibration)
from dolo.numeric.processes import ProductProcess, Process
if isinstance(exogenous, Process):
# old style
return exogenous
elif isinstance(exo, list):
# old style (2)
return ProductProcess(*exogenous)
else:
# new style
syms = self.symbols['exogenous']
# first we check that shocks are defined in the right order
ssyms = []
for k in exo.keys():
vars = [v.strip() for v in k.split(',')]
ssyms.append(vars)
ssyms = tuple(sum(ssyms, []))
if tuple(syms) != ssyms:
from dolang.language import ModelError
lc = exo.lc
raise ModelError(
f"{lc.line}:{lc.col}: 'exogenous' section. Shocks specification must match declaration order. Found {ssyms}. Expected{tuple(syms)}"
)
return ProductProcess(*exogenous.values())
def distribution(self):
# old style only
calib = self.calibration.flat
if "distribution" in self.data:
return eval_data(self.data["distribution"], calibration=calib)
else:
return None
def endo_grid(self):
# determine bounds:
domain = self.get_domain()
min = domain.min
max = domain.max
options = self.data.get("options", {})
# determine grid_type
grid_type = get_type(options.get("grid"))
if grid_type is None:
grid_type = get_address(self.data,
["options:grid:type", "options:grid_type"])
if grid_type is None:
raise Exception('Missing grid geometry ("options:grid:type")')
args = {"min": min, "max": max}
if grid_type.lower() in ("cartesian", "cartesiangrid"):
from dolo.numeric.grids import UniformCartesianGrid
orders = get_address(self.data,
["options:grid:n", "options:grid:orders"])
if orders is None:
orders = [20] * len(min)
grid = UniformCartesianGrid(min=min, max=max, n=orders)
elif grid_type.lower() in ("nonuniformcartesian",
"nonuniformcartesiangrid"):
from dolang.language import eval_data
from dolo.numeric.grids import NonUniformCartesianGrid
calibration = self.get_calibration()
nodes = [
eval_data(e, calibration) for e in self.data["options"]["grid"]
]
# each element of nodes should be a vector
return NonUniformCartesianGrid(nodes)
elif grid_type.lower() in ("smolyak", "smolyakgrid"):
from dolo.numeric.grids import SmolyakGrid
mu = get_address(self.data, ["options:grid:mu"])
if mu is None:
mu = 2
grid = SmolyakGrid(min=min, max=max, mu=mu)
else:
raise Exception("Unknown grid type.")
return grid
def get_address(data, address, default=None):
if isinstance(address, list):
found = [get_address(data, e, None) for e in address]
found = [f for f in found if f is not None]
if len(found) > 0:
return found[0]
else:
return default
fields = str.split(address, ":")
while len(fields) > 0:
data = data.get(fields[0])
fields = fields[1:]
if data is None:
return default
return eval_data(data)
def get_domain(self):
calibration = self.get_calibration()
states = self.symbols["states"]
sdomain = self.data.get("domain", {})
for k in sdomain.keys():
if k not in states:
sdomain.pop(k)
# backward compatibility
if len(sdomain) == 0 and len(states) > 0:
try:
import warnings
min = get_address(self.data,
["options:grid:a", "options:grid:min"])
max = get_address(self.data,
["options:grid:b", "options:grid:max"])
for i, s in enumerate(states):
sdomain[s] = [min[i], max[i]]
# shall we raise a warning for deprecated syntax ?
except Exception as e:
pass
if len(sdomain) == 0:
return None
if len(sdomain) < len(states):
missing = [s for s in states if s not in sdomain]
raise Exception("Missing domain for states: {}.".format(
str.join(", ", missing)))
from dolo.compiler.objects import CartesianDomain
from dolang.language import eval_data
sdomain = eval_data(sdomain, calibration)
domain = CartesianDomain(**sdomain)
return domain
def exogenous(self):
# old style only
calib = self.calibration.flat
return eval_data(self.data["exogenous"], calibration=calib)