def test_and_operand(self):
A = count(0, step=2)
B = count(1, step=2)
one = EdgeSet(UEdge(next(A), next(B)) for _ in range(200))
self.assertEqual(len(one), 200)
self.assertTrue(hasattr(one, "__and__"))
C = count(200, step=2)
D = count(201, step=2)
two = EdgeSet(UEdge(next(C), next(D)) for _ in range(200))
self.assertEqual(len(two), 200)
three = one & two
self.assertIsInstance(three, EdgeSet)
self.assertEqual(len(three), 100)
four = two & one
self.assertEqual(len(four), len(three))
self.assertIsInstance(four, EdgeSet)
self.assertEqual(three, four)
def gen_random_prim(stpg: SteinerTreeProblem):
terminals = set(stpg.terminals)
graph = stpg.graph
vi = sample(range(1, stpg.nro_nodes + 1), k=1)[0]
done = set()
edges = set()
result = EdgeSet()
done.add(vi)
terminals.discard(vi)
for w in graph.adjacent_to(vi):
edges.add((vi, w))
while edges and terminals:
edge = sample(edges, k=1)[0]
v, w = edge
if w not in done:
done.add(w)
result.add(v, w)
terminals.discard(w)
for u in graph.adjacent_to(w):
if u not in done: edges.add((w, u))
edges.discard((v, w))
return result
def __call__(self, parent_a, parent_b):
assert isinstance(
parent_a, EdgeSet
), f'parent_a has to be EdgeSet type. Give was {type(parent_a)}'
assert isinstance(
parent_b, EdgeSet
), f'parent_b has to be EdgeSet type. Give was {type(parent_b)}'
edges = parent_a | parent_b
done = DisjointSets()
for v in edges.vertices:
done.make_set(v)
edges = set(edges)
result = EdgeSet()
while edges and len(done.get_disjoint_sets()) > 1:
edge = sample(edges, k=1)[0]
y, z = edge[0], edge[1]
if done.find(y) != done.find(z):
result.add(edge)
done.union(y, z)
edges.discard(edge)
return result
def __call__(self, parent_a, parent_b):
assert isinstance(
parent_a, EdgeSet
), f'parent_a has to be EdgeSet type. Give was {type(parent_a)}'
assert isinstance(
parent_b, EdgeSet
), f'parent_b has to be EdgeSet type. Give was {type(parent_b)}'
stpg = self.stpg
terminals = set(stpg.terminals)
subgraph = UGraph()
for edge in parent_a:
u, v = edge
subgraph.add_edge(u, v)
for edge in parent_b:
u, v = edge
subgraph.add_edge(u, v)
done = set()
result = EdgeSet()
v = terminals.pop()
while terminals:
done.add(v)
adjacents = subgraph.adjacent_to(v, lazy=False)
u = sample(adjacents, k=1)[0]
if u not in done:
result.add(v, u)
terminals.discard(u)
v = u
return result
def test_copy_method(self):
A = count(0, step=2)
B = count(1, step=2)
items = [ (next(A), next(B)) for _ in range(200)]
result = EdgeSet(items)
self.assertTrue(hasattr(result, 'copy'))
copied = result.copy()
with self.subTest("test instance returned"):
self.assertIsInstance(copied, EdgeSet)
with self.subTest("have they same lenght?"):
self.assertEqual(len(result), len(copied))
with self.subTest("are they equal?"):
self.assertTrue(result == copied)
self.assertTrue(copied == result)
with self.subTest("are they the same?"):
self.assertFalse(copied is result)
self.assertFalse(result is copied)
with self.subTest("have they the same edges?"):
self.assertEqual(result._edges, copied._edges)
def test_sub_operand(self):
A = count(0, step=2)
B = count(1, step=2)
one = EdgeSet(UEdge(next(A), next(B)) for _ in range(200))
self.assertEqual(len(one), 200)
self.assertTrue(hasattr(one, "__sub__"))
C = count(200, step=2)
D = count(201, step=2)
two = EdgeSet(UEdge(next(C), next(D)) for _ in range(200))
self.assertEqual(len(two), 200)
three = one - two
self.assertIsInstance(three, EdgeSet)
self.assertEqual(len(three), 100)
A = count(0, step=2)
B = count(1, step=2)
three_expected = EdgeSet(UEdge(next(A), next(B)) for _ in range(100))
self.assertEqual(three, three_expected)
def test_or_operand(self):
A = count(0, step=2)
B = count(1, step=2)
one = EdgeSet(UEdge(next(A), next(B)) for _ in range(200))
self.assertEqual(len(one), 200)
self.assertTrue(hasattr(one, "__or__"))
C = count(200, step=2)
D = count(201, step=2)
two = EdgeSet(UEdge(next(C), next(D)) for _ in range(200))
self.assertEqual(len(two), 200)
three = one | two
self.assertIsInstance(three, EdgeSet)
self.assertEqual(len(three), 300)
four = two | one
self.assertEqual(len(four), len(three))
self.assertIsInstance(four, EdgeSet)
self.assertEqual(three, four)
E = count(0, step=2)
F = count(1, step=2)
five = EdgeSet(UEdge(next(E), next(F)) for _ in range(300))
self.assertEqual(three, five)
self.assertEqual(four, five)
def test_add_an_edge(self):
items = [(8, 9), (7, 4),(5,3), (2,1)]
result = EdgeSet(items)
edge = UEdge(40, 50)
self.assertFalse(edge in result)
self.assertEqual(len(result), len(items))
self.assertTrue(hasattr(result, 'add'))
result.add(edge)
self.assertTrue(edge in result)
self.assertEqual(len(result), len(items) + 1)
def test_init_with_edgeset(self):
A = count(0, step=2)
B = count(1, step=2)
items = [ (next(A), next(B)) for _ in range(200)]
result = EdgeSet(items)
other = EdgeSet(result)
self.assertFalse(other is result)
self.assertFalse(other._edges is result._edges)
self.assertEqual(result, other)
self.assertEqual(other._edges, result._edges)
self.assertEqual(len(result), len(other))
def test_if_choices_works(self):
A = count(0, step=2)
B = count(1, step=2)
edges = EdgeSet(UEdge(next(A), next(B)) for _ in range(200))
arbitrary_edges = choices(edges, k=5)
def test_if_random_sample_works(self):
A = count(0, step=2)
B = count(1, step=2)
edges = EdgeSet(UEdge(next(A), next(B)) for _ in range(200))
arbitrary = sample(edges, k=10)
def gen_random_walk(stpg: SteinerTreeProblem):
graph = stpg.graph
terminals = set(stpg.terminals)
result = EdgeSet()
done = set()
v = terminals.pop()
while terminals:
done.add(v)
adjacents = graph.adjacent_to(v, lazy=False)
u = sample(adjacents, k=1)[0]
if u not in done:
result.add(v, u)
terminals.discard(u)
v = u
return result
def test_vertices_after_add_a_new_edge(self):
items = [
(8, 6), (7, 4),(5,3), (2,1),
(8, 7), (8, 4), (8, 5), (8, 2)
]
result = EdgeSet(items)
self.assertEqual(len(result), len(items))
self.assertTrue(hasattr(result, 'vertices'))
vertices = set([v for v in result.vertices])
self.assertEqual(len(vertices), 8)
result.add(47, 5)
result.add(23, 4)
vertices_b = set([v for v in result.vertices])
self.assertEqual(len(vertices_b), 10)
self.assertEqual(len(result), len(items) + 2)
def test_apply_random_sample(self):
A = count(0, step=2)
B = count(1, step=2)
items = list((next(A), next(B)) for _ in range(200))
obj = EdgeSet(items)
result = sample(list(obj), k=10)
self.assertEqual(len(result), 10)
def test_convert_to_list(self):
A = count(0, step=2)
B = count(1, step=2)
edges = EdgeSet(UEdge(next(A), next(B)) for _ in range(200))
result = list(edges)
self.assertIsInstance(result, list)
self.assertEqual(len(result), 200)
def test_clear_method(self):
A = count(0, step=2)
B = count(1, step=2)
items = [ (next(A), next(B)) for _ in range(200)]
result = EdgeSet(items)
self.assertTrue(hasattr(result, 'clear'))
with self.subTest("Has it elements?"):
self.assertTrue(result)
self.assertTrue(len(result))
self.assertEqual(len(result), 200)
result.clear()
with self.subTest("There isn't elements anymore."):
self.assertFalse(result)
self.assertFalse(len(result))
self.assertEqual(len(result), 0)
def test_not_equal_operand(self):
A = count(0, step=2)
B = count(1, step=2)
obj_1 = EdgeSet((next(A), next(B)) for _ in range(200))
self.assertTrue(hasattr(obj_1, '__ne__'))
C = count(398, step=-2)
D = count(399, step=-2)
obj_2 = EdgeSet((next(C), next(D)) for _ in range(200))
self.assertFalse(obj_2 != obj_1)
self.assertFalse(obj_1 != obj_2)
E = count(400, step=2)
F = count(401, step=2)
obj_3 = EdgeSet((next(E), next(F)) for _ in range(200))
self.assertTrue(obj_1 != obj_3)
self.assertTrue(obj_3 != obj_1)
def __call__(self, parent_a, parent_b):
assert isinstance(
parent_a, EdgeSet
), f'parent_a has to be EdgeSet type. Give was {type(parent_a)}'
assert isinstance(
parent_b, EdgeSet
), f'parent_b has to be EdgeSet type. Give was {type(parent_b)}'
stpg = self.stpg
terminals = set(stpg.terminals)
done = set()
result = EdgeSet()
subgraph = UGraph()
for edge in parent_a:
u, v = edge
subgraph.add_edge(u, v)
for edge in parent_b:
u, v = edge
subgraph.add_edge(u, v)
vi = terminals.pop()
done.add(vi)
candidates_edges = set()
for u in subgraph.adjacent_to(vi):
candidates_edges.add((vi, u))
while candidates_edges and terminals:
edge = sample(candidates_edges, k=1)[0]
v, w = edge
if w not in done:
done.add(w)
result.add(v, w)
terminals.discard(w)
for u in subgraph.adjacent_to(w):
if u not in done: candidates_edges.add((w, u))
candidates_edges.discard((v, w))
return result
def test_contains(self):
A = count(0, step=2)
B = count(1, step=2)
items = [ (next(A), next(B)) for _ in range(200)]
result = EdgeSet(items)
self.assertTrue(hasattr(result, "__contains__"))
self.assertTrue(UEdge(8, 9) in result)
self.assertTrue(UEdge(9, 8) in result)
self.assertFalse(UEdge(8, 7) in result)
self.assertFalse(UEdge(7, 8) in result)
def test_len_property(self):
A = count(0, step=2)
B = count(1, step=2)
items = [ (next(A), next(B)) for _ in range(200)]
result = EdgeSet(items)
self.assertTrue(hasattr(result, '__len__'))
with self.subTest("How many edges?"):
self.assertEqual(len(result), 200)
with self.subTest("How many edges? len(items)"):
self.assertEqual(len(result), len(items))
def test_init_with_set_of_tuples(self):
A = count(0, step=2)
B = count(1, step=2)
items = {(next(A), next(B)) for _ in range(200)}
self.assertIsInstance(items, set)
self.assertTrue(all(isinstance(item, tuple) for item in items))
result = EdgeSet(items)
self.assertIsInstance(result, EdgeSet)
self.assertEqual(len(result), 200)
self.assertIsInstance(result._edges, set)
def gen_random_kruskal(stpg: SteinerTreeProblem):
terminals = set(stpg.terminals)
edges = [(u, v) for u, v in stpg.graph.gen_undirect_edges()]
shuffle(edges)
done = DisjointSets()
for v in terminals:
done.make_set(v)
result = EdgeSet()
while edges and len(done.get_disjoint_sets()) > 1:
edge = edges.pop()
y, z = edge[0], edge[1]
if y not in done: done.make_set(y)
if z not in done: done.make_set(z)
if done.find(y) != done.find(z):
result.add(y, z)
done.union(y, z)
terminals.discard(y)
terminals.discard(z)
return result
def test_init_with_list_of_edges(self):
A = count(0, step=2)
B = count(1, step=2)
items = list(UEdge(next(A), next(B)) for _ in range(200))
self.assertIsInstance(items, list)
self.assertTrue(all(isinstance(item, UEdge) for item in items))
result = EdgeSet(items)
self.assertIsInstance(result, EdgeSet)
self.assertEqual(len(result), 200)
self.assertIsInstance(result._edges, set)
self.assertTrue(all(isinstance(edge, UEdge) for edge in result))
def test_vertices_property(self):
A = count(0, step=2)
B = count(1, step=2)
items = [(next(A), next(B)) for _ in range(200)]
result = EdgeSet(items)
self.assertTrue(hasattr(result, 'vertices'))
self.assertIsInstance(result.vertices, Generator)
C = count(0, step=2)
D = count(1, step=2)
aa = set(next(C) for _ in range(200))
bb = set(next(D) for _ in range(200))
cc = aa.union(bb)
nodes = [v for v in result.vertices]
self.assertEqual(len(nodes), len(cc))
def test_xor_operand(self):
A = count(0, step=2)
B = count(1, step=2)
one = EdgeSet(UEdge(next(A), next(B)) for _ in range(200))
self.assertEqual(len(one), 200)
self.assertTrue(hasattr(one, "__xor__"))
C = count(200, step=2)
D = count(201, step=2)
two = EdgeSet(UEdge(next(C), next(D)) for _ in range(200))
self.assertEqual(len(two), 200)
three = one ^ two
self.assertIsInstance(three, EdgeSet)
self.assertEqual(len(three), 200)
four = two ^ one
self.assertEqual(three, four)
self.assertIsInstance(four, EdgeSet)
E = count(0, step=2)
F = count(1, step=2)
five = EdgeSet(UEdge(next(E), next(F)) for _ in range(100))
six = EdgeSet((next(E), next(F)) for _ in range(100))
items = [(next(E), next(F)) for _ in range(100)]
for item in items:
five.add(item)
self.assertEqual(len(five), 200)
self.assertEqual(three, five)
self.assertEqual(four, five)
seven = six & five
self.assertEqual(len(seven), 0)
self.assertFalse(seven)
self.assertIsInstance(seven, EdgeSet)
def test_if_is_iterable(self):
A = count(0, step=2)
B = count(1, step=2)
items = [ (next(A), next(B)) for _ in range(200)]
result = EdgeSet(items)
self.assertTrue(hasattr(result, '__iter__'))
self.assertIsInstance(iter(result), Iterator)
total = 0
for _ in result:
total += 1
self. assertEqual(len(result), total)
total_again = 0
for _ in result:
total_again += 1
self.assertEqual(total, total_again)
def test_path_like_solution(self):
filename = path.join('tests', 'data', 'test3.txt')
stpg = ReaderORLibrary().parser(filename)
after = EdgeSet()
after.add(1, 3)
after.add(3, 8)
after.add(8, 5)
after.add(5, 6)
evaluate = EvaluateEdgeSet(stpg)
mutate = MutationReplaceByRandomEdge(stpg)
cost_after, _ = evaluate(after)
self.assertEqual(cost_after, (5 + 7 + 7 + 15))
before = mutate(after)
self.assertEqual(after, before)
cost_before, _ = evaluate(before)
self.assertEqual(cost_after, cost_before)
def test_init_empty(self):
edset = EdgeSet()
self.assertFalse(len(edset))
def test_remove_method(self):
items = [
(8, 6), (7, 4), (5,3), (2, 1),
(8, 7), (8, 4), (8, 5), (8, 2)
]
result = EdgeSet(items)
self.assertEqual(len(result), len(items))
self.assertTrue(hasattr(result, 'remove'))
with self.subTest("without exception: tuple"):
result.remove((5, 8))
self.assertEqual(len(result), len(items) - 1)
with self.subTest("without exception: args"):
result.remove(2, 1)
self.assertEqual(len(result), len(items) - 2)
with self.subTest("without exception: list"):
result.remove([4, 7])
self.assertEqual(len(result), len(items) - 3)
with self.subTest("without exception: list"):
result.remove(UEdge(7, 8))
self.assertEqual(len(result), len(items) - 4)
with self.subTest("with exception"):
with self.assertRaises(KeyError):
result.remove((101, 105))
with self.subTest("with exception: alredy removed"):
with self.assertRaises(KeyError):
result.remove((8, 5))
def test_discard_method(self):
items = [
(8, 6), (7, 4), (5,3), (2, 1),
(8, 7), (8, 4), (8, 5), (8, 2)
]
result = EdgeSet(items)
self.assertEqual(len(result), len(items))
self.assertTrue(hasattr(result, 'discard'))
with self.subTest("without exception: tuple"):
result.discard((5, 8))
self.assertEqual(len(result), len(items) - 1)
with self.subTest("without exception: args"):
result.discard(2, 1)
self.assertEqual(len(result), len(items) - 2)
with self.subTest("without exception: list"):
result.discard([4, 7])
self.assertEqual(len(result), len(items) - 3)
with self.subTest("without exception: list"):
result.discard(UEdge(7, 8))
self.assertEqual(len(result), len(items) - 4)
with self.subTest("without exception: alredy taken"):
result.discard(UEdge(7, 8))
self.assertEqual(len(result), len(items) - 4)
with self.subTest("without exception: non exists previously"):
result.discard(UEdge(7, 8))
self.assertEqual(len(result), len(items) - 4)
