def testDistributiveLaw(self):
A, B, C, D, E = get_symbols(2, 1, 1, 1, 1)
self.assertEquals((A + B) << (C + D + E),
Concatenation(A << (C + D), B << E))
self.assertEquals((C + D + E) << (A + B),
Concatenation((C + D) << A, E << B))
self.assertEquals((A + B) << (C + D + E) << (A + B),
Concatenation(A << (C + D) << A, B << E << B))
self.assertEquals(SeriesProduct.create((A + B), (C + D + E), (A + B)),
Concatenation(A << (C + D) << A, B << E << B))
test_perm = (0, 1, 3, 2)
qtp = CPermutation(test_perm)
self.assertEquals(
CPermutation((1, 0)) << (B + C),
SeriesProduct(Concatenation(C, B), CPermutation((1, 0))))
self.assertEquals(qtp << (A + B + C), (A + C + B) << qtp)
self.assertEquals(qtp << (B + C + A), B + C + (CPermutation(
(1, 0)) << A))
test_perm2 = (1, 0, 3, 2)
qtp2 = CPermutation(test_perm2)
self.assertEquals(qtp2 << (A + B + C), (CPermutation(
(1, 0)) << A) + ((C + B) << CPermutation((1, 0))))
self.assertEquals(qtp << qtp2,
CPermutation(permute(test_perm, test_perm2)))
def testSeries(self):
self.assertEqual(
parse_circuit_strings('a(2) << b(2)'),
SeriesProduct(CircuitSymbol('a', 2), CircuitSymbol('b', 2)))
self.assertEqual(
parse_circuit_strings('a(5) << b(5) << c(5)'),
SeriesProduct(CircuitSymbol('a', 5), CircuitSymbol('b', 5),
CircuitSymbol('c', 5)))
def testSeries(self):
A, B = get_symbol(1), get_symbol(1)
self.assertEquals( A << B, SeriesProduct(A,B))
self.assertEquals( A<< B, SeriesProduct.create(A,B))
# need at least two operands
# self.assertRaises(Exception, SeriesProduct, ())
# self.assertRaises(Exception, SeriesProduct.create, ())
# self.assertRaises(Exception, SeriesProduct, (A,))
self.assertEquals(SeriesProduct.create(A), A)
def testSeries(self):
A, B = get_symbol(1), get_symbol(1)
self.assertEquals(A << B, SeriesProduct(A, B))
self.assertEquals(A << B, SeriesProduct.create(A, B))
# need at least two operands
# self.assertRaises(Exception, SeriesProduct, ())
# self.assertRaises(Exception, SeriesProduct.create, ())
# self.assertRaises(Exception, SeriesProduct, (A,))
self.assertEquals(SeriesProduct.create(A), A)
def testDrawNested(self):
self.assertCanBeDrawn(
SeriesProduct(
CircuitSymbol('a', 2),
Concatenation(CircuitSymbol('b', 1), CircuitSymbol('c', 1))))
self.assertCanBeDrawn(
Concatenation(
CircuitSymbol('a', 2),
SeriesProduct(CircuitSymbol('b', 1), CircuitSymbol('c', 1))))
self.assertCanBeDrawn(
Feedback(
Concatenation(
CircuitSymbol('a', 2),
SeriesProduct(CircuitSymbol('b', 1),
CircuitSymbol('c', 1))), 2, 0))
def testSeriesFilterIdentities(self):
for n in (1,2,3, 10):
A, B = get_symbol(n), get_symbol(n)
idn = circuit_identity(n)
self.assertEquals(A << idn, A)
self.assertEquals(idn << A, A)
self.assertEquals(SeriesProduct.create(idn, idn, A, idn, idn, B, idn, idn), A << B)
def testDistributiveLaw(self):
A, B, C, D, E = get_symbols(2,1,1,1,1)
self.assertEquals((A+B) << (C+D+E), Concatenation(A<<(C+D), B << E))
self.assertEquals((C+D+E) << (A+B) , Concatenation((C+D)<< A, E<< B))
self.assertEquals((A+B) << (C+D+E) << (A+B) , Concatenation(A << (C+D)<< A, B << E<< B))
self.assertEquals(SeriesProduct.create((A+B), (C+D+E), (A+B)), Concatenation(A << (C+D)<< A, B << E<< B))
test_perm = (0,1,3,2)
qtp = CPermutation(test_perm)
self.assertEquals(CPermutation((1,0)) << ( B + C), SeriesProduct(Concatenation(C, B), CPermutation((1,0))))
self.assertEquals(qtp << (A + B + C), (A + C+ B) << qtp)
self.assertEquals(qtp << ( B + C + A) , B + C + (CPermutation((1,0)) << A))
test_perm2 = (1,0,3,2)
qtp2 = CPermutation(test_perm2)
self.assertEquals(qtp2 << (A + B + C), (CPermutation((1,0)) << A) + ((C+B) << CPermutation((1,0))))
self.assertEquals(qtp << qtp2, CPermutation(permute(test_perm, test_perm2)))
def testNested(self):
self.assertEqual(
parse_circuit_strings('a(2) << (b(1) + c(1))'),
SeriesProduct(
CircuitSymbol('a', 2),
Concatenation(CircuitSymbol('b', 1), CircuitSymbol('c', 1))))
self.assertEqual(
parse_circuit_strings('a(2) + (b(1) << c(1))'),
Concatenation(
CircuitSymbol('a', 2),
SeriesProduct(CircuitSymbol('b', 1), CircuitSymbol('c', 1))))
self.assertEqual(
parse_circuit_strings('[a(2) + (b(1) << c(1))]_(2->0)'),
Feedback(
Concatenation(
CircuitSymbol('a', 2),
SeriesProduct(CircuitSymbol('b', 1),
CircuitSymbol('c', 1))), 2, 0))
def testSeriesFilterIdentities(self):
for n in (1, 2, 3, 10):
A, B = get_symbol(n), get_symbol(n)
idn = circuit_identity(n)
self.assertEquals(A << idn, A)
self.assertEquals(idn << A, A)
self.assertEquals(
SeriesProduct.create(idn, idn, A, idn, idn, B, idn, idn),
A << B)
def testDrawSeries(self):
self.assertCanBeDrawn(
SeriesProduct(CircuitSymbol('a', 5), CircuitSymbol('b', 5)))
def testFactorizePermutation(self):
self.assertEqual(full_block_perm((0, 1, 2), (1, 1, 1)), (0, 1, 2))
self.assertEqual(full_block_perm((0, 2, 1), (1, 1, 1)), (0, 2, 1))
self.assertEqual(full_block_perm((0, 2, 1), (1, 1, 2)), (0, 3, 1, 2))
self.assertEqual(full_block_perm((0, 2, 1), (1, 2, 3)),
(0, 4, 5, 1, 2, 3))
self.assertEqual(full_block_perm((1, 2, 0), (1, 2, 3)),
(3, 4, 5, 0, 1, 2))
self.assertEqual(full_block_perm((3, 1, 2, 0), (1, 2, 3, 4)),
(9, 4, 5, 6, 7, 8, 0, 1, 2, 3))
self.assertEqual(block_perm_and_perms_within_blocks((9, 4, 5, 6, 7, 8, 0, 1, 2, 3 ), (1,2,3,4)), \
((3,1,2,0), [(0,),(0,1),(0,1,2),(0,1,2,3)]))
A1, A2, A3, A4 = get_symbols(1, 2, 3, 4)
new_lhs, permuted_rhs, new_rhs = P_sigma(
9, 4, 5, 6, 7, 8, 0, 1, 2, 3)._factorize_for_rhs(A1 + A2 + A3 + A4)
self.assertEqual(new_lhs, cid(10))
self.assertEqual(permuted_rhs, (A4 + A2 + A3 + A1))
self.assertEqual(new_rhs, P_sigma(9, 4, 5, 6, 7, 8, 0, 1, 2, 3))
p = P_sigma(0, 1, 4, 2, 3, 5)
expr = A2 + A3 + A1
new_lhs, permuted_rhs, new_rhs = p._factorize_for_rhs(expr)
self.assertEqual(new_lhs, cid(6))
self.assertEqual(permuted_rhs, A2 + (P_sigma(2, 0, 1) << A3) + A1)
self.assertEqual(new_rhs, cid(6))
p = P_sigma(0, 3, 1, 2)
p_r = P_sigma(2, 0, 1)
assert p == cid(1) + p_r
A = get_symbol(2)
new_lhs, permuted_rhs, new_rhs = p._factorize_for_rhs(
cid(1) + A + cid(1))
self.assertEqual(new_lhs, P_sigma(0, 1, 3, 2))
self.assertEqual(permuted_rhs,
(cid(1) + (P_sigma(1, 0) << A) + cid(1)))
self.assertEqual(new_rhs, cid(4))
new_lhs, permuted_rhs, new_rhs = p._factorize_for_rhs(cid(2) + A)
self.assertEqual(new_lhs, cid(4))
self.assertEqual(permuted_rhs, (cid(1) + A + cid(1)))
self.assertEqual(new_rhs, p)
self.assertEqual(
p.series_inverse() << (cid(2) + A),
cid(1) + SeriesProduct(
P_sigma(0, 2, 1),
Concatenation(SeriesProduct(P_sigma(1, 0), A), cid(1)),
P_sigma(2, 0, 1)))
self.assertEqual(
p.series_inverse() << (cid(2) + A) << p,
cid(1) + (p_r.series_inverse() << (cid(1) + A) << p_r))
new_lhs, permuted_rhs, new_rhs = P_sigma(4, 2, 1, 3,
0)._factorize_for_rhs(
(A4 + cid(1)))
self.assertEqual(new_lhs, cid(5))
self.assertEqual(permuted_rhs, (cid(1) + (P_sigma(3, 1, 0, 2) << A4)))
self.assertEqual(new_rhs, map_signals_circuit({4: 0}, 5))
## special test case that helped find the major permutation block structure factorization bug
p = P_sigma(3, 4, 5, 0, 1, 6, 2)
q = cid(3) + CircuitSymbol('NAND1', 4)
new_lhs, permuted_rhs, new_rhs = p._factorize_for_rhs(q)
self.assertEqual(new_lhs, P_sigma(0, 1, 2, 6, 3, 4, 5))
self.assertEqual(permuted_rhs,
(P_sigma(0, 1, 3, 2) << CircuitSymbol('NAND1', 4)) +
cid(3))
self.assertEqual(new_rhs, P_sigma(4, 5, 6, 0, 1, 2, 3))
