def test_max_flow_scale_free_directed(n):
seed_number = randint(1, 1000)
generator = ScaleFree(n, directed=True, seed_number=seed_number)
graph, source, target = generator.generate()
solver = GoldbergWave(graph)
max_flow = solver.get_max_flow(source, target)
generator = ScaleFree(n, directed=True, seed_number=seed_number)
graph, source, target = generator.generate()
res = gt.push_relabel_max_flow(graph, source, target, graph.ep.cap)
res.a = graph.ep.cap.a - res.a # the actual flow
gt_max_flow = sum(res[e] for e in target.in_edges())
assert max_flow == gt_max_flow
def test_max_flow_scale_random_undirected(size):
seed_number = randint(1, 1000)
generator = Random(size[0], size[1], directed=False, seed_number=seed_number)
graph, source, target = generator.generate()
solver = GoldbergWave(graph)
max_flow = solver.get_max_flow(source, target)
generator = Random(size[0], size[1], directed=False, seed_number=seed_number)
graph, source, target = generator.generate()
res = gt.push_relabel_max_flow(graph, source, target, graph.ep.cap)
res.a = graph.ep.cap.a - res.a # the actual flow
gt_max_flow = sum(res[e] for e in target.in_edges())
assert max_flow == gt_max_flow
def get_algorithm(algorithm, graph):
if algorithm == 'generic':
return Goldberg(graph)
elif algorithm == 'height':
return GoldbergHeight(graph)
elif algorithm == 'wave':
return GoldbergWave(graph)
def test_max_flow_triangulation_delaunay_directed(n):
seed_number = randint(1, 1000)
generator = Triangulation(n,
type="delaunay",
directed=True,
seed_number=seed_number)
graph, source, target = generator.generate()
solver = GoldbergWave(graph)
max_flow = solver.get_max_flow(source, target)
generator = Triangulation(n,
type="delaunay",
directed=True,
seed_number=seed_number)
graph, source, target = generator.generate()
res = gt.push_relabel_max_flow(graph, source, target, graph.ep.cap)
res.a = graph.ep.cap.a - res.a # the actual flow
gt_max_flow = sum(res[e] for e in target.in_edges())
assert max_flow == gt_max_flow
from max_flow_wave import GoldbergWave
import math
from generation.ScaleFree import ScaleFree
from generation.Triangulation import Triangulation
from generation.Random import Random
file = open("temporal_complexity_data_wave", "w")
for nodes in [100, 200 ,300, 400, 500]:
for i in range(0, 15):
#Goldberg version - using as graph generator Random
seed_number = randint(1, 1000)
generator = Random(nodes, nodes*4, directed=True, seed_number=seed_number)
g, source, target = generator.generate()
title = '- Parte grafo versione Wave con ' + str(nodes) + ' nodi e ' + str(len(g.get_edges())) + ' archi - Random.'
print(title)
file.write(title)
solver = GoldbergWave(graph=g)
pr = cProfile.Profile()
pr.enable()
solution = solver.get_max_flow(source, target)
pr.disable()
s = StringIO()
sortby = 'cumulative'
ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
ps.print_stats()
file.write(s.getvalue())
file.close()
res = gt.push_relabel_max_flow(g, src, tgt, cap)
res.a = cap.a - res.a # the actual flow
max_flow = sum(res[e] for e in tgt.in_edges())
print("Il max flow trovato da GraphTool è:", max_flow)
labels = g.new_edge_property("string")
for edge in g.edges():
labels[edge] = str(res[edge]) + "/" + str(cap[edge])
gt.graph_draw(g,
edge_pen_width=gt.prop_to_size(res, mi=1, ma=5, power=1),
output="max-flow-library-solution.pdf",
vertex_text=g.vertex_index,
edge_text=labels)
# using WaveImplementation, find the solution to test and print the resulting graph
solver = GoldbergWave(graph=g)
solution = solver.get_max_flow(src, tgt)
print("Il max flow trovato da Wave è:", solution)
labels = g.new_vertex_property("string")
for vertex in g.vertices():
labels[vertex] = str(g.vertex_index[vertex]) + "(" + str(
g.vp.height[vertex]) + "," + str(g.vp.excess[vertex]) + ")"
gt.graph_draw(g,
edge_pen_width=gt.prop_to_size(g.ep.residual,
mi=1,
ma=5,
power=1),
output="max-flow-wave-solution.pdf",
vertex_text=labels,