def test_parsing():
from dolang.grammar import str_expression, sanitize
from dolang.symbolic import parse_string
e = parse_string("s + a(0) + b[t-1] + b[t] + b[t+1]")
print(e.pretty())
e = parse_string("chi*n^eta*c^sigma - w(1)")
print(e.pretty())
e = parse_string("chi*n^eta*c^sigma - w(1) | 0.01 <= n <= 1.0")
print(e.pretty())
e = parse_string("chi*n^eta*c^sigma - w(1) ⟂ 0.01 <= n <= 1.0")
print(e.pretty())
e = parse_string("i = exp(z)*k^alpha*n^(1-alpha) - (m)^(-1/sigma)")
print(e.pretty())
f = sanitize(e, variables=["m"])
print(str_expression(f))
s = "i = exp(z)*k^alpha*n^(1-alpha) - (m)^(-1/sigma)"
e = parse_string(s)
s = "i = exp(z)*k^alpha*n^(1-alpha) - (m)^(-1/sigma)"
# vars = ['z', 'p', 'k', 'n', 'i', 'm', 'V', 'u', 'y', 'c', 'rk', 'w', 'y', 'c']
# print("HI")
# v = sanitize(s, variables=vars)
# print(v)
e = parse_string(s)
print(str_expression(e))
def test_predicate():
from dolang.symbolic import parse_string, str_expression
e = parse_string("a[t] <= (x[t]+b)")
print(e.pretty())
print(str_expression(e))
e = parse_string("∀t, a[t] <= (x[t]+b)")
print(e.pretty())
print(str_expression(e))
def test_subperiod():
from dolang.symbolic import parse_string, str_expression
e = parse_string("a[t$1] = a[t+1]")
print(e.pretty())
print(str_expression(e))
e = parse_string("a[t$consumption] = a[t+1]")
print(e.pretty())
print(str_expression(e))
from lark.lark import Lark
def test_expectation():
from dolang.symbolic import parse_string
s = "�[ (x[t+1] / x[t]) ]"
e = parse_string(s)
print(e.pretty())
from dolang.symbolic import str_expression
print(str_expression(e))
def eval_formula(expr: str, dataframe=None, context=None):
"""
expr: string
Symbolic expression to evaluate.
Example: `k(1)-delta*k(0)-i`
table: (optional) pandas dataframe
Each column is a time series, which can be indexed with dolo notations.
context: dict or CalibrationDict
"""
if context is None:
dd = {} # context dictionary
elif isinstance(context, CalibrationDict):
dd = context.flat.copy()
else:
dd = context.copy()
# compat since normalize form for parameters doesn't match calib dict.
for k in [*dd.keys()]:
dd[stringify_symbol(k)] = dd[k]
expr_ast = parse_string(expr)
variables = list_variables(expr_ast)
nexpr = stringify(expr_ast)
dd["log"] = log
dd["exp"] = exp
if dataframe is not None:
import pandas as pd
for (k, t) in variables:
dd[stringify_symbol((k, t))] = dataframe[k].shift(t)
dd["t_"] = pd.Series(dataframe.index, index=dataframe.index)
expr = str_expression(nexpr)
res = eval(expr.replace("^", "**"), dd)
return res
def get_factory(model, eq_type: str, tshift: int = 0):
from dolo.compiler.model import decode_complementarity
from dolo.compiler.recipes import recipes
from dolang.symbolic import stringify, stringify_symbol
equations = model.equations
if eq_type == "auxiliary":
eqs = ["{}".format(s) for s in model.symbols["auxiliaries"]]
specs = {
"eqs": [
["exogenous", 0, "m"],
["states", 0, "s"],
["controls", 0, "x"],
["parameters", 0, "p"],
]
}
else:
eqs = equations[eq_type]
if eq_type in ("arbitrage_lb", "arbitrage_ub"):
specs = {
"eqs":
recipes["dtcc"]["specs"]["arbitrage"]["complementarities"]
["left-right"]
}
else:
specs = recipes["dtcc"]["specs"][eq_type]
specs = shift_spec(specs, tshift=tshift)
preamble_tshift = set([s[1] for s in specs["eqs"] if s[0] == "states"])
preamble_tshift = preamble_tshift.intersection(
set([s[1] for s in specs["eqs"] if s[0] == "controls"]))
args = []
for sg in specs["eqs"]:
if sg[0] == "parameters":
args.append([s for s in model.symbols["parameters"]])
else:
args.append([(s, sg[1]) for s in model.symbols[sg[0]]])
args = [[stringify_symbol(e) for e in vg] for vg in args]
arguments = dict(zip([sg[2] for sg in specs["eqs"]], args))
# temp
eqs = [eq.split("⟂")[0].strip() for eq in eqs]
if "target" in specs:
sg = specs["target"]
targets = [(s, sg[1]) for s in model.symbols[sg[0]]]
eqs = [eq.split("=")[1] for eq in eqs]
else:
eqs = [("({1})-({0})".format(*eq.split("=")) if "=" in eq else eq)
for eq in eqs]
targets = [("out{}".format(i), 0) for i in range(len(eqs))]
eqs = [str.strip(eq) for eq in eqs]
eqs = [dolang.parse_string(eq) for eq in eqs]
es = Sanitizer(variables=model.variables)
eqs = [es.transform(eq) for eq in eqs]
eqs = [time_shift(eq, tshift) for eq in eqs]
eqs = [stringify(eq) for eq in eqs]
eqs = [str_expression(eq) for eq in eqs]
targets = [stringify_symbol(e) for e in targets]
# sanitize defs ( should be )
defs = dict()
for k in model.definitions:
val = model.definitions[k]
# val = es.transform(dolang.parse_string(val))
for t in preamble_tshift:
s = stringify(time_shift(k, t))
if isinstance(val, str):
vv = stringify(time_shift(val, t))
else:
vv = str(val)
defs[s] = vv
preamble = reorder_preamble(defs)
eqs = dict(zip(targets, eqs))
ff = FlatFunctionFactory(preamble, eqs, arguments, eq_type)
return ff