def test_list_symbols():
from dolang.symbolic import parse_string
e = parse_string('sin(a(1)+b+f(1)+f(+4)+a(1))+cos(0)')
ll = list_symbols(e)
# cos is recognized as a usual function
assert (ll.variables == [('a', 1), ('f', 1), ('f', 4)])
assert (ll.parameters == ['b'])
e = parse_string('sin(a(1)+b+f(1)+f(+4)+a(1))+cos(0)')
ll = list_symbols(e, funs=['f'])
# now we add a custom function
assert (ll.variables == [('a', 1)])
assert (ll.parameters == ['b'])
def test_list_symbols():
from dolang.symbolic import parse_string
e = parse_string("sin(a(1)+b+f(1)+f(4)+a(1))+cos(0)")
ll = list_symbols(e)
print(ll.variables)
print(ll.parameters)
# cos is recognized as a usual function
assert ll.variables == [("a", 1), ("f", 1), ("f", 4)]
assert ll.parameters == ["b"]
def definitions(self):
from yaml import ScalarNode
if self.__definitions__ is None:
# at this stage, basic_symbols doesn't contain auxiliaries
basic_symbols = self.symbols
vars = sum(
[
basic_symbols[k]
for k in basic_symbols.keys() if k != "parameters"
],
[],
)
# # auxiliaries = [remove_timing(parse_string(k)) for k in self.data.get('definitions', {})]
# # auxiliaries = [str_expression(e) for e in auxiliaries]
# # symbols['auxiliaries'] = auxiliaries
if "definitions" not in self.data:
self.__definitions__ = {}
# self.__symbols__['auxiliaries'] = []
elif isinstance(self.data["definitions"], ScalarNode):
definitions = {}
# new-style
from lark import Token
def_block_tree = parse_string(self.data["definitions"],
start="assignment_block")
def_block_tree = sanitize(
def_block_tree
) # just to replace (v,) by (v,0) # TODO: remove
auxiliaries = []
for eq_tree in def_block_tree.children:
lhs, rhs = eq_tree.children
tok_name: Token = lhs.children[0].children[0]
tok_date: Token = lhs.children[1].children[0]
name = tok_name.value
date = int(tok_date.value)
if name in vars:
raise Exception(
f"definitions:{tok_name.line}:{tok_name.column}: Auxiliary variable '{name}'' already defined."
)
if date != 0:
raise Exception(
f"definitions:{tok_name.line}:{tok_name.column}: Auxiliary variable '{name}' must be defined at date 't'."
)
# here we could check some stuff
from dolang import list_symbols
syms = list_symbols(rhs)
for p in syms.parameters:
if p in vars:
raise Exception(
f"definitions:{tok_name.line}: Symbol '{p}' is defined as a variable. Can't appear as a parameter."
)
if p not in self.symbols["parameters"]:
raise Exception(
f"definitions:{tok_name.line}: Paremeter '{p}' must be defined as a model symbol."
)
for v in syms.variables:
if v[0] not in vars:
raise Exception(
f"definitions:{tok_name.line}: Variable '{v[0]}[t]' is not defined."
)
auxiliaries.append(name)
vars.append(name)
definitions[str_expression(lhs)] = str_expression(rhs)
self.__symbols__["auxiliaries"] = auxiliaries
self.__definitions__ = definitions
else:
# old style
from dolang.symbolic import remove_timing
auxiliaries = [
remove_timing(parse_string(k))
for k in self.data.get("definitions", {})
]
auxiliaries = [str_expression(e) for e in auxiliaries]
self.__symbols__["auxiliaries"] = auxiliaries
vars = self.variables
auxs = []
definitions = self.data["definitions"]
d = dict()
for i in range(len(definitions.value)):
kk = definitions.value[i][0]
if self.__compat__:
k = parse_string(kk.value)
if k.data == "symbol":
# TODO: warn that definitions should be timed
from dolang.grammar import create_variable
k = create_variable(k.children[0].value, 0)
else:
k = parse_string(kk.value, start="variable")
k = sanitize(k, variables=vars)
assert k.children[1].children[0].value == "0"
vv = definitions.value[i][1]
v = parse_string(vv, start="formula")
v = sanitize(v, variables=vars)
v = str_expression(v)
key = str_expression(k)
vars.append(key)
d[key] = v
auxs.append(remove_timing(key))
self.__symbols__["auxiliaries"] = auxs
self.__definitions__ = d
return self.__definitions__