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))