def test_has(): my_map = Map({1: 1, -2: -2, 0: 0}) assert my_map.has(Z(1)) == Bool.true() assert my_map.has(Z(-2)) == Bool.true() assert my_map.has(Z(-200)) == Bool.false() assert Map.empty().has(Z(-200)) == Bool.false()
def test_lt_(): assert Z(1).__lt__(Z(0)) == Bool.false() assert Z(1).__lt__(Z(-1)) == Bool.false() assert Z(-1).__lt__(Z(-2)) == Bool.false() assert Z(0).__lt__(Z(0)) == Bool.false() assert Z(-1).__lt__(Z(-1)) == Bool.false()
def test_remove(): my_map = Map({1: 1, -2: -2, 0: 0}) assert not (my_map.remove(Z(1)) == my_map) assert my_map.remove(Z(1)) == Map({-2: -2, 0: 0}) assert my_map.remove(Z(100)) == my_map assert Map.empty().remove(Z(10)) == Map.empty()
def test_add_(): assert List([]) + List([]) == List.empty() assert List([]) + List([1]) == List([1]) assert List([1]) + List([]) == List([1]) assert List([-1]) + List([0]) == List.cons(tail=List.cons( tail=List.empty(), head=Z(-1)), head=Z(0)) assert List([-1]) + List([0, 1]) == List.cons(tail=List.cons( tail=List.cons(tail=List.empty(), head=Z(-1)), head=Z(0)), head=Z(1))
def __init__(self, *args, **kwargs): if (len(args) == 1) and isinstance(args[0], dict): d = args[0] Sort.__init__(self) if not (d): self._generator = Map.empty else: key = list(d.keys())[0] value = d.pop(list(d.keys())[0]) self._generator = Map.add self._generator_args = { 'my_map': Map(d), 'key': Z(key), 'value': Z(value) } else: Sort.__init__(self, **kwargs)
def __init__(self, *args, **kwargs): if(len(args) == 1) and isinstance(args[0], Sequence): Sort.__init__(self) if len(args[0]) == 0: self._generator = List.empty else: self._generator = List.cons self._generator_args = {'tail': List(args[0][:-1]), 'head': Z(args[0][-1])} else: Sort.__init__(self, **kwargs)
def test_constructor(): assert Map({}) == Map.empty() assert Map({1: 1}) == Map.add(my_map=Map.empty(), key=Z(1), value=Z(1)) assert Map({ 1: 1, -2: -2 }) == Map.add(my_map=Map.add(my_map=Map.empty(), key=Z(-2), value=Z(-2)), key=Z(1), value=Z(1))
def test_normalize(): # this should be 0 z = Z.cons(pos=Nat(1), neg=Nat(1)) # we normalize it assert z.normalize() == Z(0) z = Z.cons(pos=Nat(1), neg=Nat(0)) assert z.normalize() == Z(1) z = Z.cons(pos=Nat(0), neg=Nat(1)) assert z.normalize() == Z(-1)
def test_generator(): # because the Z.zero == Z.cons(pos=Nat(0), neg=Nat(0)) assert Z.zero()._generator == Z.cons assert Z.cons(pos=Nat(0), neg=Nat(0))._generator == Z.cons
def test_pop(): assert List([-1, 0, 1]).pop() == (List([-1, 0]), Z(1)) assert List([]).pop() == (List.empty(), List.empty())
def test_sub_(): assert Z(0) - Z(0) == Z(0) assert Z(1) - Z(0) == Z(1) assert Z(0) - Z(-1) == Z(1) assert Z(0) - Z(1) == Z(-1)
def test_add_(): assert Z(0) + Z(0) == Z(0) assert Z(1) + Z(0) == Z(1) assert Z(0) + Z(-1) == Z(-1)
def test_constructor(): assert Z(0) == Z.cons(pos=Nat(0), neg=Nat(0)) assert Z(1) == Z.cons(pos=Nat(1), neg=Nat(0)) assert Z(-1) == Z.cons(pos=Nat(0), neg=Nat(1))
def test_generator(): assert List.empty()._generator == List.empty assert List.cons(tail=List.empty(), head=Z.zero())._generator == List.cons
def test_constructor(): assert List([]) == List.empty() assert List([-1, 0, 1]) == List.cons(tail=List.cons(tail=List.cons( tail=List.empty(), head=Z(-1)), head=Z(0)), head=Z(1))
def test_str_(): assert Z(0).__str__() == 'Z(Nat(0))' assert Z(1).__str__() == 'Z(Nat(1))' assert Z(-1).__str__() == 'Z(-Nat(1))'
def test_get_value(): my_map = Map({1: 1, -2: -2, 0: 0}) assert my_map.get_value(Z(1)) == Z(1) assert my_map.get_value(Z(-2)) == Z(-2) assert my_map.get_value(Z(-3)) == Map.empty()
def eval_expr(expr: Expr, context: Context) -> Literal: # literal if expr == Expr.expr_lit(var.lit): return var.lit # variable if expr == Expr.expr_variable(var.var_name): lit = Context.get_value(c=context, k=var.var_name) return lit # unary operations if expr == Expr.expr_unary(op=var.op, expr=var.expr): lit = Prog.eval_expr(expr=var.expr, context=context) # not if (var.op == Unary_op.o_not()) & (lit == Literal.lit_bool(var.bool)): return Literal.lit_bool(~var.bool) # uSub if (var.op == Unary_op.uSub()) & (lit == Literal.lit_z(var.literal)): return Literal.lit_z((Z(0) - var.literal)) pass # binary operations if expr == Expr.expr_binary(op=var.op, expr1=var.expr1, expr2=var.expr2): lit1 = Prog.eval_expr(expr=var.expr1, context=context) lit2 = Prog.eval_expr(expr=var.expr2, context=context) # add if (var.op == Binary_op.add()) & (lit1 == Literal.lit_z(var.literal1)) & (lit2 == Literal.lit_z(var.literal2)): return Literal.lit_z(var.literal1 + var.literal2) # sub if (var.op == Binary_op.sub()) & (lit1 == Literal.lit_z(var.literal1)) & (lit2 == Literal.lit_z(var.literal2)): return Literal.lit_z(var.literal1 - var.literal2) # mult if (var.op == Binary_op.mult()) & (lit1 == Literal.lit_z(var.literal1)) & (lit2 == Literal.lit_z(var.literal2)): return Literal.lit_z(var.literal1 * var.literal2) # div if (var.op == Binary_op.div()) & (lit1 == Literal.lit_z(var.literal1)) & (lit2 == Literal.lit_z(var.literal2)): return Literal.lit_z(var.literal1 / var.literal2) # modulo if (var.op == Binary_op.modulo()) & (lit1 == Literal.lit_z(var.literal1)) & (lit2 == Literal.lit_z(var.literal2)): return Literal.lit_z(var.literal1 % var.literal2) # and if (var.op == Binary_op.o_and()) & (lit1 == Literal.lit_bool(var.literal1)) & (lit2 == Literal.lit_bool(var.literal2)): return Literal.lit_bool(var.literal1 & var.literal2) # or if (var.op == Binary_op.o_or()) & (lit1 == Literal.lit_bool(var.literal1)) & (lit2 == Literal.lit_bool(var.literal2)): return Literal.lit_bool(var.literal1 | var.literal2) # xor if (var.op == Binary_op.xor()) & (lit1 == Literal.lit_bool(var.literal1)) & (lit2 == Literal.lit_bool(var.literal2)): return Literal.lit_bool(var.literal1 ^ var.literal2) pass
def test_generator(): assert Map.empty()._generator == Map.empty assert Map.add(my_map=Map.empty(), key=Z.zero(), value=Z.zero())._generator == Map.add