def setUp(self):
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.n10 = node(10, 'k', [], [11])
self.n11 = node(11, 'm', [10], [])
self.d0 = open_digraph([0], [1], [self.n0, self.n1])
self.d5 = open_digraph([3], [2], [self.n0, self.n1])
self.d11 = open_digraph([10], [11], [self.n10, self.n11])
self.d10 = open_digraph([0, 10], [1, 11], [self.n0, self.n1, self.n10, self.n11])
def test_copy(self):
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
self.d2 = open_digraph([],[],[])
d2 = self.d0.copy()
d2.inputs = [1]
self.assertEqual(d2.outputs, self.d0.outputs)
self.assertNotEqual(d2.inputs, self.d0.inputs)
self.assertIsNot(d2,self.d0)
def test_is_cyclic(self):
self.n0 = node(0, 'a', [2], [1])
self.n1 = node(1, 'b', [0], [2])
self.n2 = node(2, 'c', [1], [0])
self.d0 = open_digraph([0],[2],[self.n0, self.n1, self.n2])
self.assertTrue(self.d0.is_cyclic())
self.b0 = node(0, 'a', [], [1])
self.b1 = node(1, 'b', [0], [2])
self.b2 = node(2, 'c', [1], [])
self.b = open_digraph([0],[2],[self.b0, self.b1, self.b2])
self.assertFalse(self.b.is_cyclic())
def test_compose(self):
b0 = node(0, 'a', [], [1])
b1 = node(1, 'b', [0], [2])
b2 = node(2, 'c', [1], [])
b = open_digraph([0],[2],[b0, b1, b2])
b2 = open_digraph([0],[2],[b0, b1, b2])
c0 = node(0, 'a', [], [1, 2])
c1 = node(1, 'b', [0], [])
c2 = node(2, 'c', [0], [])
c0 = open_digraph([0],[1,2],[c0, c1, c2])
f = c0.compose(b)
c0.icompose(b)
def test_icompose(self):
b0 = node(0, 'a', [], [1])
b1 = node(1, 'b', [0], [2])
b2 = node(2, 'c', [1], [])
b = open_digraph([0],[2],[b0, b1, b2])
b2 = open_digraph([0],[2],[b0, b1, b2])
c0 = node(0, 'a', [], [1, 2])
c1 = node(1, 'b', [0], [])
c2 = node(2, 'c', [0], [])
c0 = open_digraph([0],[1,2],[c0, c1, c2])
c0.icompose(b)
self.assertEqual(c0.get_node_ids(), [1,2,3,4,5])
self.assertEqual(c0.get_inputs_ids(), [3])
self.assertEqual(c0.get_outputs_ids(), [1,2])
def remove_edge(self):
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
self.remove_edge(n1,n0)
self.assertEqual(self.n0.get_children_ids(), [])
self.assertEqual(self.n1.get_parent_ids(), [])
def test_remove_edges(self):
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
self.d0.remove_edges([self.n1],[self.n0]) #tester avec plusieurs noeuds
self.assertEqual(self.n0.get_children_ids(), [])
self.assertEqual(self.n1.get_parent_ids(), [])
def test_change_ids(self):
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
print(self.d0)
self.d0.change_ids([(1,3),(0,2)])
print(self.d0)
def test_add_edge(self):
self.n0 = node(0, 'a', [], [2])
self.n1 = node(1, 'b', [3], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
self.d0.add_edge(self.n0.get_id(), self.n1.get_id())
self.assertEqual(self.n0.get_children_ids(), [2,1])
self.assertEqual(self.n1.get_parent_ids(), [3,0])
def parse_parenthese(s):
'''fonction qui transfore une formule propositionnelle en circuit booleen
argument : s : string, la formule propociitonnelle a transformer
return : un circuit booleen '''
prems = node(0, '', [], [])
g = open_digraph([], [0], [prems])
bc = bool_circ_mx(g)
current_node = 0
s2 = ''
for char in s:
if (char == '('):
bc.get_node_by_id(current_node).set_label(
bc.get_node_by_id(current_node).get_label() +
s2) # il faut concatener
new = bc.add_node(label='',
parents=[],
children=[current_node])
current_node = new
s2 = ''
else:
if (char == ')'):
bc.get_node_by_id(current_node).set_label(
bc.get_node_by_id(current_node).get_label() + s2)
id = bc.get_node_by_id(current_node).get_children_ids()
current_node = id[0]
s2 = ''
else:
s2 = s2 + char
return bc
def parse_parenthese_3(s): # s une sequence de chaine de caractere
# Utiliser les fonctions de composition paralleles (attention aux entrees a fusionner)
graph_list = []
bc = open_digraph([], [], [])
for chaine in s:
graph_list.append(bool_circ_mx.parse_parenthese_2(chaine))
#print("pp3", graph_list)
bc = bc.parallel2(graph_list, None, None)
return bc
def test_connected_components(self):
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.n2 = node(2, 'a', [], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1, self.n2])
nb_cc, dict = self.d0.connected_components()
#print("test_cc", nb_cc, dict)
self.assertEqual(nb_cc, 2)
self.assertEqual(dict, {0 : 0, 1 : 0, 2 : 1})
def test_add_edges(self):
self.n0 = node(0, 'a', [], [3])
self.n1 = node(1, 'b', [4], [])
self.n2 = node(2, 'a', [], [5])
self.d0 = open_digraph([0],[1],[self.n0, self.n1, self.n2])
self.d0.add_edges(self.n0.get_id(), [self.n1.get_id(), self.n2.get_id()])
self.assertEqual(self.n0.get_children_ids(), [3,1,2])
self.assertEqual(self.n1.get_parent_ids(), [4,0])
self.assertEqual(self.n2.get_parent_ids(), [0])
def test_shift_indice(self):
self.n0 = node(0, 'a', [2], [1])
self.n1 = node(1, 'b', [0], [2])
self.n2 = node(2, 'c', [1], [0])
self.d0 = open_digraph([0],[2],[self.n0, self.n1, self.n2])
self.d0.shift_indices(3)
self.assertEqual(self.d0.get_node_ids(), [3,4,5])
self.b0 = node(0, 'a', [], [1])
self.b1 = node(1, 'b', [0], [2])
self.b2 = node(2, 'c', [1], [])
self.b = open_digraph([0],[2],[self.b0, self.b1, self.b2])
self.b.shift_indices(-7)
self.assertEqual(self.b.get_node_ids(), [-7, -6, -5])
self.c0 = node(0, 'a', [2], [1])
self.c1 = node(1, 'b', [0], [2])
self.c2 = node(2, 'c', [1], [0])
self.c0 = open_digraph([0],[2],[self.c0, self.c1, self.c2])
self.c0.shift_indices(8)
self.assertEqual(self.c0.get_node_ids(), [8,9,10])
'''self.f0 = node(0, 'a', [2], [1])
def convert(self, circ):
'''methode qui convertit un circuit en graphe
arguments : circ, circuit a convertir
return : g, le graphe correspondant au circuit circ
'''
#circ : un circuit booléen bool_circ
g = open_digraph([], [], [])
g.inputs = self.get_inputs_ids()
g.nodes = self.get_nodes()
g.outputs = self.get_outputs_ids()
return g
def parse_parenthese_2(s):
prems = node(0, '', [], [])
g = open_digraph([], [0], [prems])
bc = bool_circ_mx(g)
current_node = 0
s2 = ''
for char in s:
if (char == '('):
bc.get_node_by_id(current_node).set_label(
bc.get_node_by_id(current_node).get_label() +
s2) # il faut concatener
new = bc.add_node(label='',
parents=[],
children=[current_node])
current_node = new
s2 = ''
else:
if (char == ')'):
bc.get_node_by_id(current_node).set_label(
bc.get_node_by_id(current_node).get_label() + s2)
id = bc.get_node_by_id(current_node).get_children_ids()
current_node = id[0]
s2 = ''
else:
s2 = s2 + char
#il ajouter aux inputs les nodes qui n'ont pas de parents
for node1 in bc.get_nodes():
if (node1.get_parent_ids() == []):
bc.add_input_id(node1.get_id())
#Il faut fusionner les nodes qui ont le meme label
fusionner = True
#print(bc.get_inputs_ids())
while (fusionner):
fusionner = False
for i in range(len(bc.get_inputs_ids())):
#print("i = ", i)
nodei = bc.get_node_by_id(bc.get_inputs_ids()[i])
labeli = nodei.get_label()
#print("labeli = ",labeli)
#print("fusionner = ", fusionner)
for j in range(i + 1, len(bc.get_inputs_ids())):
#print("j = ", j )
nodej = bc.get_node_by_id(bc.get_inputs_ids()[j])
labelj = nodej.get_label()
#print("labelj = ",labelj)
#print("fusionner = ", fusionner)
if (labeli == labelj and nodei != nodej):
#print("fusioooooooon !")
fusionner = True
bc.fusion_nodes(nodei.get_id(), nodej.get_id())
#print("pouet")
return bc
def test_get_inputs_ids(self):
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
self.assertEqual(self.d0.get_inputs_ids(),[0])
self.assertNotEqual(self.d0.get_inputs_ids(),[1])
def test_get_id_node_map(self):
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
self.d1 = open_digraph([0],[1],[self.n0, self.n1])
def test_id_exists_in_graph(self):
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
self.assertTrue(self.d0.id_exists_in_graph(0))
self.assertFalse(self.d0.id_exists_in_graph(2))
def test_change_id(self): # a tester
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
self.d0.change_id(0,2)
def test_remove_nodes_by_id(self):
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
self.d0.remove_nodes_by_id([1,0]) #tester avec plusieurs ids
self.assertEqual(self.d0.get_nodes(), [])
def test_get_node_by_ids(self):
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
self.assertEqual(self.d0.get_node_by_ids([0,1]),[self.n0,self.n1])
def test_remove_node_by_id(self):
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
self.d0.remove_node_by_id(1)
self.assertEqual(self.d0.get_nodes(), [self.n0])
def test_init_open_digraph(self): #a completer ici - Question 3
n0 = node(0, 'i', [], [1])
n1 = node(1,'b',[],[2])
self.g = open_digraph([1],[3],[n0,n1])
self.assertEqual(self.g.inputs, [1])
self.assertEqual(self.g.outputs, [3])
def test_add_node(self):
self.n0 = node(0, 'a', [], [2])
self.n1 = node(1, 'b', [3], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
self.d0.add_node(label = 'c', parents = [1], children = [0])
self.assertEqual(len(self.d0.get_node_ids()), 3)
def test_new_id(self):
self.n0 = node(0, 'a', [], [1])
self.n1 = node(1, 'b', [0], [])
self.d0 = open_digraph([0],[1],[self.n0, self.n1])
