def pro(p):
if p[1].gettokentype() == 'SUM':
return Sum(p[0], p[2])
if p[1].gettokentype() == 'SUB':
return Sub(p[0], p[2])
if p[1].gettokentype() == 'MUL':
return Sub(p[0], p[2])
if p[1].gettokentype() == 'DIV':
return Sub(p[0], p[2])
def parse_equation(eq_string, vars, substract_lhs=True, to_sympy=False):
sds = StandardizeDatesSimple(vars)
eq = eq_string.split('|')[0] # ignore complentarity constraints
if '==' not in eq:
eq = eq.replace('=', '==')
expr = ast.parse(eq).body[0].value
expr_std = sds.visit(expr)
from dolo.compiler.codegen import to_source
if isinstance(expr_std, Compare):
lhs = expr.left
rhs = expr.comparators[0]
if substract_lhs:
expr_std = BinOp(left=rhs, right=lhs, op=Sub())
else:
if to_sympy:
return [ast_to_sympy(lhs), ast_to_sympy(rhs)]
return [lhs, rhs]
if to_sympy:
return ast_to_sympy(expr_std)
else:
return expr_std
def expression(p):
left = p[0]
right = p[2]
operator = p[1]
if operator.gettokentype() == 'SUM':
return Sum(left, right)
elif operator.gettokentype() == 'SUB':
return Sub(left, right)
def expression(p):
left = p[0]
right = p[2]
operator = p[1]
if operator.gettokentype() == 'SUM':
return Sum(self.builder, self.module, left, right)
elif operator.gettokentype() == 'SUB':
return Sub(self.builder, self.module, left, right)
def expr_binop(p):
left = p[0]
right = p[2]
if p[1].gettokentype() == 'PLUS':
return Add(self.builder, self.module, left, right)
elif p[1].gettokentype() == 'MINUS':
return Sub(self.builder, self.module, left, right)
else:
raise AssertionError('Oops, this should not be possible!')
def expression(p):
left = p[0]
right = p[2]
op = p[1]
if op.gettokentype() == 'ADD':
return Add(self.builder, self.module, left, right)
elif op.gettokentype() == 'SUB':
return Sub(self.builder, self.module, left, right)
def p_expr(tokens):
op = tokens[1].gettokentype()
left = tokens[0]
right = tokens[2]
if (op == 'PLUS'):
return Sum(left, right)
if (op == 'MINUS'):
return Sub(left, right)
else:
raise Exception(f"{tokens} passaram liso")
def expressao(p):
left = p[0]
right = p[2]
operator = p[1]
if operator.gettokentype() == 'SOMA':
return Sum(self.builder, self.module, left, right)
elif operator.gettokentype() == 'SUB':
return Sub(self.builder, self.module, left, right)
elif operator.gettokentype() == 'MUL':
return Mul(self.builder, self.module, left, right)
elif operator.gettokentype() == 'DIV':
return Div(self.builder, self.module, left, right)
def expression(p): left = p[0] right = p[2] operator = p[1] if operator.gettokentype() == 'NHAN': return Mul(self.builder, self.module, left, right) elif operator.gettokentype() == 'CHIA': return Div(self.builder, self.module, left, right) elif operator.gettokentype() == 'CONG': return Sum(self.builder, self.module, left, right) elif operator.gettokentype() == 'TRU': return Sub(self.builder, self.module, left, right)
def expression_binop(p):
left = p[0]
right = p[2]
if p[1].gettokentype() == 'PLUS':
return Add(left, right)
elif p[1].gettokentype() == 'MINUS':
return Sub(left, right)
elif p[1].gettokentype() == 'MUL':
return Mul(left, right)
elif p[1].gettokentype() == 'DIV':
return Div(left, right)
else:
raise AssertionError('Oops, this should not be possible!')
def expression(p) -> BinaryOp:
left = p[0]
right = p[2]
operator = p[1]
t = operator.gettokentype()
if t == 'SUM':
return Sum(self.builder, self.module, left, right)
elif t == 'SUB':
return Sub(self.builder, self.module, left, right)
elif t == 'MUL':
return Mul(self.builder, self.module, left, right)
elif t == 'DIV':
return Div(self.builder, self.module, left, right)
def token2obj(token):
if token == '+':
return Add()
elif token == '-':
return Sub()
elif token == '*':
return Mult()
elif token == '/':
return Div()
try:
return Num(int(token))
except:
pass
return Name(id=token)
def expression(p):
left = p[0]
right = p[2]
operator = p[1]
if operator.gettokentype() == 'SUM':
return Sum(left, right)
elif operator.gettokentype() == 'SUB':
return Sub(left, right)
elif operator.gettokentype() == 'MUL':
return Mul(left, right)
elif operator.gettokentype() == 'DIV':
return Div(left, right)
elif operator.gettokentype() == 'POW':
return Pow(left, right)
elif operator.gettokentype() == 'MOD':
return Mod(left, right)
def arith_expr(self, a):
a, op, b = a
op = {
'+': Add(),
'-': Sub(),
'*': Mult(),
'@': MatMult(),
'/': Div(),
'//': FloorDiv(),
'%': Mod(),
'&': BitAnd(),
'|': BitOr(),
'^': BitXor(),
'<<': LShift(),
'>>': RShift(),
}.get(op, None)
return BinOp(left=a, op=op, right=b)
def expression(p):
left = p[0]
right = p[2]
operator = p[1]
if operator.gettokentype() == 'PLUS':
return Sum(left, right)
elif operator.gettokentype() == 'MINUS':
return Sub(left, right)
elif operator.gettokentype() == 'MULT':
return Mult(left, right)
elif operator.gettokentype() == 'DIV':
return Div(left, right)
elif operator.gettokentype() == 'ASSIGN':
return Assign(left, right)
elif operator.gettokentype() == 'GREATERTHAN':
return GreaterThan(left, right)
elif operator.gettokentype() == 'LESSTHAN':
return LessThan(left, right)
elif operator.gettokentype() == 'EQUAL':
return Equal(left, right)
def expression_arg(p):
left = p[0]
right = p[2]
operator = p[1]
if isinstance(p[0], Identificador):
if p[0].nome in self.vars.keys():
left = self.vars[p[0].nome]
if isinstance(p[2], Identificador):
if p[2].nome in self.vars.keys():
right = self.vars[p[2].nome]
if operator.gettokentype() == 'ADD':
return Add(left, right)
elif operator.gettokentype() == 'SUB':
return Sub(left, right)
elif operator.gettokentype() == 'MULT':
return Mult(left, right)
elif operator.gettokentype() == 'DIV':
return Div(left, right)
def _make_print(self, ns: List[expr], prefix: str = None) -> Expr:
# create the indent: ' ' * depth
mul_by = Name(self._DEPTH_VAR, Load())
indent = BinOp(Constant(" "), Mult(), mul_by)
# if prefix is given, indent is: ' ' * (depth - len(prefix)) + prefix
if prefix is not None:
assert len(
prefix
) <= self._INDENT, f"too long {prefix} for given indent {self._INDENT}"
indent.right = BinOp(mul_by, Sub(), Constant(len(prefix)))
indent = BinOp(indent, Add(), Constant(prefix))
return Expr(
Call(
Name("print", Load()),
args=cast(List[expr], [indent]) + ns,
keywords=[
keyword("sep", Constant("")),
keyword("file",
Attribute(Name("sys", Load()), "stderr", Load())),
],
))
def visit_AugAssign(self, ast_aug_assign: AugAssign):
# need to do some trick of +=, -=, *=, /=
if type(ast_aug_assign.op) == Add:
new_op = BinOp(ast_aug_assign.target, Add(), ast_aug_assign.value)
elif type(ast_aug_assign.op) == Sub:
new_op = BinOp(ast_aug_assign.target, Sub(), ast_aug_assign.value)
elif type(ast_aug_assign.op) == Mult:
new_op = BinOp(ast_aug_assign.target, Mult(), ast_aug_assign.value)
elif type(ast_aug_assign.op) == Div:
new_op = BinOp(ast_aug_assign.target, Div(), ast_aug_assign.value)
else:
raise Exception("does not support operator: ", ast_aug_assign.op)
ast_assign = Assign(ast_aug_assign.target, new_op)
# create Big-O AST assign node
assign_node = AssignNode()
# coord = coordinate(ast_aug_assign.col_offset, ast_aug_assign.lineno)
# self.set_coordinate(assign_node, coord)
assign_node.target = self.visit(ast_assign.targets)
assign_node.value = self.visit(ast_assign.value)
return assign_node
def parse_equation(eq_string, vars, substract_lhs=True, to_sympy=False):
eq = eq_string.split('|')[0] # ignore complentarity constraints
if '==' not in eq:
eq = eq.replace('=', '==')
expr = ast.parse(eq).body[0].value
expr_std = normalize(expr, variables=vars)
if isinstance(expr_std, Compare):
lhs = expr_std.left
rhs = expr_std.comparators[0]
if substract_lhs:
expr_std = BinOp(left=rhs, right=lhs, op=Sub())
else:
if to_sympy:
return [ast_to_sympy(lhs), ast_to_sympy(rhs)]
return [lhs, rhs]
if to_sympy:
return ast_to_sympy(expr_std)
else:
return expr_std
def _decrement_depth(self) -> AugAssign:
return AugAssign(Name(self._DEPTH_VAR, Store()), Sub(),
Constant(self._INDENT))
expr_func=None,
),
expr=None,
lineno=None,
**maybe_type_comment,
),
Return(
value=Call(
args=[
Call(
args=[
Call(
args=[
BinOp(
set_value(1.0),
Sub(),
BinOp(
Attribute(
Name("self", Load()),
"y_true",
Load(),
),
Mult(),
Attribute(
Name("self", Load()),
"y_pred",
Load(),
),
),
),
set_value(0.0),
def make_function(equations,
arguments,
parameters,
targets=None,
rhs_only=False,
definitions={},
funname='anonymous'):
compat = lambda s: s.replace("^", "**").replace('==', '=').replace(
'=', '==')
equations = [compat(eq) for eq in equations]
if isinstance(arguments, list):
arguments = OrderedDict([('arg_{}'.format(i), k)
for i, k in enumerate(arguments)])
## replace = by ==
known_variables = [a[0] for a in sum(arguments.values(), [])]
known_definitions = [a for a in definitions.keys()]
known_parameters = [a[0] for a in parameters]
all_variables = known_variables + known_definitions
known_functions = []
known_constants = []
if targets is not None:
all_variables.extend([o[0] for o in targets])
targets = [std_tsymbol(o) for o in targets]
else:
targets = ['_out_{}'.format(n) for n in range(len(equations))]
all_symbols = all_variables + known_parameters
equations = [parse(eq) for eq in equations]
definitions = {k: parse(v) for k, v in definitions.items()}
defs_incidence = {}
for sym, val in definitions.items():
cn = CountNames(known_definitions, [], [])
cn.visit(val)
defs_incidence[(sym, 0)] = cn.variables
# return defs_incidence
from dolo.compiler.codegen import to_source
equations_incidence = {}
to_be_defined = set([])
for i, eq in enumerate(equations):
cn = CountNames(all_variables, known_functions, known_constants)
cn.visit(eq)
equations_incidence[i] = cn.variables
to_be_defined = to_be_defined.union(
[a for a in cn.variables if a[0] in known_definitions])
deps = []
for tv in to_be_defined:
ndeps = get_deps(defs_incidence, tv)
deps.extend(ndeps)
deps = [d for d in unique(deps)]
sds = StandardizeDatesSimple(all_symbols)
new_definitions = OrderedDict()
for k in deps:
val = definitions[k[0]]
nval = timeshift(val, all_variables, k[1]) # function to print
# dprint(val)
new_definitions[std_tsymbol(k)] = sds.visit(nval)
new_equations = []
for n, eq in enumerate(equations):
d = match(parse("_x == _y"), eq)
if d is not False:
lhs = d['_x']
rhs = d['_y']
if rhs_only:
val = rhs
else:
val = ast.BinOp(left=rhs, op=Sub(), right=lhs)
else:
val = eq
new_equations.append(sds.visit(val))
# preambleIndex(Num(x))
preamble = []
for i, (arg_group_name, arg_group) in enumerate(arguments.items()):
for pos, t in enumerate(arg_group):
sym = std_tsymbol(t)
rhs = Subscript(value=Name(id=arg_group_name, ctx=Load()),
slice=Index(Num(pos)),
ctx=Load())
val = Assign(targets=[Name(id=sym, ctx=Store())], value=rhs)
preamble.append(val)
for pos, p in enumerate(parameters):
sym = std_tsymbol(p)
rhs = Subscript(value=Name(id='p', ctx=Load()),
slice=Index(Num(pos)),
ctx=Load())
val = Assign(targets=[Name(id=sym, ctx=Store())], value=rhs)
preamble.append(val)
# now construct the function per se
body = []
for k, v in new_definitions.items():
line = Assign(targets=[Name(id=k, ctx=Store())], value=v)
body.append(line)
for n, neq in enumerate(new_equations):
line = Assign(targets=[Name(id=targets[n], ctx=Store())],
value=new_equations[n])
body.append(line)
for n, neq in enumerate(new_equations):
line = Assign(targets=[
Subscript(value=Name(id='out', ctx=Load()),
slice=Index(Num(n)),
ctx=Store())
],
value=Name(id=targets[n], ctx=Load()))
body.append(line)
from ast import arg, FunctionDef, Module
from ast import arguments as ast_arguments
from dolo.compiler.function_compiler_ast import to_source
f = FunctionDef(
name=funname,
args=ast_arguments(args=[arg(arg=a) for a in arguments.keys()] +
[arg(arg='p'), arg(arg='out')],
vararg=None,
kwarg=None,
kwonlyargs=[],
kw_defaults=[],
defaults=[]),
body=preamble + body,
decorator_list=[])
mod = Module(body=[f])
mod = ast.fix_missing_locations(mod)
return mod
