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