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
