def test_signed_add():
A = bitvec('A', 8)
B = bitvec('B', 8)
for adder in (rca, ksa, bka):
S, C = adder(A, B)
# 0 + 0 = 0
assert sadd(S, A, B, 0, 0) == 0
# -64 + -64 = -128
assert sadd(S, A, B, -64, -64) == -128
# -1 + 1 = 0
assert sadd(S, A, B, -1, 1) == 0
# -64 + 64 = 0
assert sadd(S, A, B, -64, 64) == 0
# signed random vectors
for i in range(NVECS):
ra = random.randint(-2**6, 2**6-1) # -64..63
rb = random.randint(-2**6, 2**6) # -64..64
assert sadd(S, A, B, ra, rb) == ra + rb
# 64 + 64, overflow
R = C.vrestrict({A: int2vec(64, 8), B: int2vec(64, 8)})
assert R[7] != R[6]
# -65 + -64, overflow
R = C.vrestrict({A: int2vec(-65, 8), B: int2vec(-64, 8)})
assert R[7] != R[6]
def test_bitvec():
assert_raises(TypeError, bitvec, 'x', "foo")
X = bitvec('x')
assert X.name == 'x'
X = bitvec('x', 4)
assert X.shape[0][0] == 0 and X.shape[0][1] == 4 and len(X.items) == 4
X = bitvec('x', (4, 8))
assert X.shape[0][0] == 4 and X.shape[0][1] == 8 and len(X.items) == 4
def test_ops():
X = bitvec('x', 4)
Y = bitvec('y', 4)
assert X.uor().equivalent(X[3] | X[2] | X[1] | X[0])
assert X.unor().equivalent(~(X[3] | X[2] | X[1] | X[0]))
assert X.uand().equivalent(X[3] & X[2] & X[1] & X[0])
assert X.unand().equivalent(~(X[3] & X[2] & X[1] & X[0]))
assert X.uxor().equivalent(X[3] ^ X[2] ^ X[1] ^ X[0])
assert X.uxnor().equivalent(~(X[3] ^ X[2] ^ X[1] ^ X[0]))
assert str(~X) == "farray([~x[0], ~x[1], ~x[2], ~x[3]])"
assert str(X | Y) == "farray([Or(x[0], y[0]), Or(x[1], y[1]), Or(x[2], y[2]), Or(x[3], y[3])])"
assert str(X & Y) == "farray([And(x[0], y[0]), And(x[1], y[1]), And(x[2], y[2]), And(x[3], y[3])])"
assert str(X ^ Y) == "farray([Xor(x[0], y[0]), Xor(x[1], y[1]), Xor(x[2], y[2]), Xor(x[3], y[3])])"
def test_decode():
A = bitvec('a', 2)
d = A.decode()
d.vrestrict({A: "00"}) == [1, 0, 0, 0]
d.vrestrict({A: "10"}) == [0, 1, 0, 0]
d.vrestrict({A: "01"}) == [0, 0, 1, 0]
d.vrestrict({A: "11"}) == [0, 0, 0, 1]
def test_shift():
X = bitvec('x', 8)
Y = bitvec('y', 4)
# left shift
assert_raises(ValueError, X.lsh, -1)
assert_raises(ValueError, X.lsh, 9)
assert_raises(ValueError, X.lsh, 2, Y)
a, b = X.lsh(4)
assert str(a) == "farray([0, 0, 0, 0, x[0], x[1], x[2], x[3]])"
assert str(b) == "farray([x[4], x[5], x[6], x[7]])"
a, b = X.lsh(4, Y)
assert str(a) == "farray([y[0], y[1], y[2], y[3], x[0], x[1], x[2], x[3]])"
assert str(b) == "farray([x[4], x[5], x[6], x[7]])"
a, b = X.lsh(0)
assert str(a) == "farray([x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7]])"
assert not b
assert_raises(TypeError, X.__lshift__, "foo")
assert str(X << 4) == "farray([0, 0, 0, 0, x[0], x[1], x[2], x[3]])"
assert str(X << (4, Y)) == "farray([y[0], y[1], y[2], y[3], x[0], x[1], x[2], x[3]])"
# right shift
assert_raises(ValueError, X.rsh, -1)
assert_raises(ValueError, X.rsh, 9)
assert_raises(ValueError, X.rsh, 2, Y)
a, b = X.rsh(4)
assert str(a) == "farray([x[4], x[5], x[6], x[7], 0, 0, 0, 0])"
assert str(b) == "farray([x[0], x[1], x[2], x[3]])"
a, b = X.rsh(4, Y)
assert str(a) == "farray([x[4], x[5], x[6], x[7], y[0], y[1], y[2], y[3]])"
assert str(b) == "farray([x[0], x[1], x[2], x[3]])"
a, b = X.rsh(0)
assert str(a) == "farray([x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7]])"
assert not b
assert_raises(TypeError, X.__rshift__, "foo")
assert str(X >> 4) == "farray([x[4], x[5], x[6], x[7], 0, 0, 0, 0])"
assert str(X >> (4, Y)) == "farray([x[4], x[5], x[6], x[7], y[0], y[1], y[2], y[3]])"
# arithmetic right shift
assert_raises(ValueError, X.arsh, -1)
assert_raises(ValueError, X.arsh, 9)
a, b = X.arsh(4)
assert str(a) == "farray([x[4], x[5], x[6], x[7], x[7], x[7], x[7], x[7]])"
assert str(b) == "farray([x[0], x[1], x[2], x[3]])"
a, b = X.arsh(0)
assert str(a) == "farray([x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7]])"
assert not b
def test_espresso():
A = bitvec('a', 16)
B = bitvec('b', 16)
S, C = ripple_carry_add(A, B)
s0, s1, s2, s3 = espresso_exprs(S[0].to_dnf(), S[1].to_dnf(),
S[2].to_dnf(), S[3].to_dnf())
assert s0.equivalent(S[0])
assert s1.equivalent(S[1])
assert s2.equivalent(S[2])
assert s3.equivalent(S[3])
X = bitvec('x', 4)
f1 = truthtable(X, "0000011111------")
f2 = truthtable(X, "0001111100------")
f1m, f2m = espresso_tts(f1, f2)
truthtable2expr(f1).equivalent(f1m)
truthtable2expr(f2).equivalent(f2m)
def test_unsigned_add():
N = 9
A = bitvec('A', N)
B = bitvec('B', N)
for adder in (rca, ksa, bka):
S, C = adder(A, B)
S.append(C[N-1])
# 0 + 0 = 0
assert uadd(S, A, B, 0, 0) == 0
# 255 + 255 = 510
assert uadd(S, A, B, 2**N-1, 2**N-1) == (2**(N+1)-2)
# 255 + 1 = 256
assert uadd(S, A, B, 2**N-1, 1) == 2**N
# unsigned random vectors
for i in range(NVECS):
ra = random.randint(0, 2**N-1)
rb = random.randint(0, 2**N-1)
assert uadd(S, A, B, ra, rb) == ra + rb
def __init__(self, varname='x'):
self.X = bitvec(varname, (1, 10), (1, 10), (1, 10))
V = And(*[
And(*[OneHot(*[self.X[r][c][v] for v in range(1, 10)])
for c in range(1, 10)])
for r in range(1, 10)])
R = And(*[
And(*[OneHot(*[self.X[r][c][v] for c in range(1, 10)])
for v in range(1, 10)])
for r in range(1, 10)])
C = And(*[
And(*[OneHot(*[self.X[r][c][v] for r in range(1, 10)])
for v in range(1, 10)])
for c in range(1, 10)])
B = And(*[
And(*[OneHot(*[self.X[3*br+r][3*bc+c][v]
for r in range(1, 4)
for c in range(1, 4)])
for v in range(1, 10)])
for br in range(3) for bc in range(3)])
self.S = expr2dimacscnf(And(V, R, C, B))
exprvar,
Expression,
Not, Or, And, Nor, Nand, Xor, Xnor, Equal, Unequal, Implies, ITE,
OneHot0, OneHot, Majority, AchillesHeel,
EXPRZERO, EXPRONE,
)
from pyeda.boolalg.vexpr import bitvec
from nose.tools import assert_raises
a, b, c, d, e, p, q, s = map(exprvar, 'abcdepqs')
MAJOR = sys.version_info.major
MINOR = sys.version_info.minor
X = bitvec('x', 16)
Y = bitvec('y', 16, 16, 16)
def test_misc():
f = a * b + a * c + b * c
assert f.smoothing(a).equivalent(b + c)
assert f.consensus(a).equivalent(b * c)
assert f.derivative(a).equivalent(b * -c + -b * c)
def test_unate():
# c' * (a' + b')
f = -c * (-a + -b)
assert f.is_neg_unate([a, b, c])
assert f.is_neg_unate([a, b])
assert f.is_neg_unate([a, c])
def test_bin2gray():
B = bitvec('B', 4)
G = bin2gray(B)
gnums = [G.vrestrict({B: uint2vec(i, 4)}).to_uint() for i in range(16)]
assert gnums == [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8]
def test_gray2bin():
G = bitvec('G', 4)
B = gray2bin(G)
gnums = [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8]
bnums = [B.vrestrict({G: uint2vec(i, 4)}).to_uint() for i in gnums]
assert bnums == list(range(16))
def test_errors():
A = bitvec('A', 7)
B = bitvec('B', 9)
for adder in (rca, ksa, bka):
assert_raises(ValueError, adder, A, B)