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 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 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_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 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_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 __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_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 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
