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 testConcatenation(self): self.assertEqual( parse_circuit_strings('a(1) + b(2)'), Concatenation(CircuitSymbol('a', 1), CircuitSymbol('b', 2))) self.assertEqual( parse_circuit_strings('a(1) + b(2) + c(3)'), Concatenation(CircuitSymbol('a', 1), CircuitSymbol('b', 2), CircuitSymbol('c', 3)))
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 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 testConcatenation(self): n = 4 A, B = get_symbol(n), get_symbol(n) id0 = circuit_identity(0) self.assertEquals(A + B, Concatenation(A, B)) self.assertEquals(A + B, Concatenation.create(A, B)) self.assertEquals(id0 + id0 + A + id0 + id0 + B + id0 + id0, A + B) # self.assertRaises(Exception, Concatenation, ()) # self.assertRaises(Exception, Concatenation, (A,)) self.assertEquals((A + B).block_structure, (n, n)) self.assertEquals((A + B).get_blocks((n, n)), (A, B)) #test index_in_block() self.assertEquals((A + B).index_in_block(0), (0, 0)) self.assertEquals((A + B).index_in_block(1), (1, 0)) self.assertEquals((A + B).index_in_block(2), (2, 0)) self.assertEquals((A + B).index_in_block(3), (3, 0)) self.assertEquals((A + B).index_in_block(4), (0, 1)) self.assertEquals((A + B).index_in_block(5), (1, 1)) self.assertEquals((A + B).index_in_block(7), (3, 1))
def testConcatenation(self): n = 4 A, B = get_symbol(n), get_symbol(n) id0 = circuit_identity(0) self.assertEquals(A+B, Concatenation(A,B)) self.assertEquals(A+B, Concatenation.create(A,B)) self.assertEquals(id0 + id0 + A + id0 + id0 + B + id0 + id0, A + B) # self.assertRaises(Exception, Concatenation, ()) # self.assertRaises(Exception, Concatenation, (A,)) self.assertEquals((A+B).block_structure, (n,n)) self.assertEquals((A+B).get_blocks((n,n)), (A,B)) #test index_in_block() self.assertEquals((A+B).index_in_block(0), (0,0)) self.assertEquals((A+B).index_in_block(1), (1,0)) self.assertEquals((A+B).index_in_block(2), (2,0)) self.assertEquals((A+B).index_in_block(3), (3,0)) self.assertEquals((A+B).index_in_block(4), (0,1)) self.assertEquals((A+B).index_in_block(5), (1,1)) self.assertEquals((A+B).index_in_block(7), (3,1))
def testDrawConcatenation(self): self.assertCanBeDrawn( Concatenation(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))