def main(outpath,
alg,
charikar_version,
charikar_mode,
pics,
k,
B,
edgesTS,
nodes,
edges,
timeIntervals,
baseline=False,
n_disc=101,
fast=True,
entire=True):
G = nx.Graph()
S = nx.Graph()
nodes_covered = list(nodes)
edges_covered = edges
baseAvg, baseInt, baseEdges, baseNodes = 0.0, 0.0, 0.0, 0.0
if baseline == True:
baseAvg, baseInt, baseS = utils.getBaseline(edgesTS, B)
baseEdges, baseNodes = baseS.number_of_edges(), baseS.number_of_nodes()
counter = 0
out = 0.0
maxiter = 0
first = True
initCom = nx.Graph()
#for maxiter in xrange(10):
for maxiter in xrange(1):
maxiter += 1
#print timeIntervals
rest_k, rest_B = k, B
G.clear()
S.clear()
if not timeIntervals:
timeIntervals = [(0, len(edgesTS) - 1)]
tic = time.clock()
############# pile a graph (unweighted)
G = utils.getGraphFrimIntervals(edgesTS, timeIntervals, charikar_mode)
#G = utils.getGraphFrimIntervals(edgesTS, timeIntervals, 'weighted_emails')
#print G.adj
#print len(G.edges())
#exit()
toc = time.clock()
#print 'pile graph', toc-tic
if pics:
plotting.plotGraph(outpath, counter, 'graph_G', G)
counter += 1
tic = time.clock()
if alg == 'dynprogr':
S, avg = charikar.charikar(copy.deepcopy(G), 'weighted',
charikar_version)
else:
S, avg = charikar.charikar(copy.deepcopy(G), 'unweighted',
charikar_version)
toc = time.clock()
#print 'Charikar', toc-tic
if first == True:
first = False
initCom = copy.deepcopy(S)
#print len(S.edges()), avg
if pics:
plotting.plotGraph(outpath, counter, 'subgraph_S', S, 'subgraph',
baseNodes, baseEdges, baseAvg)
counter += 1
nodes = S.nodes()
# simple rule:
timeIntervals = [(0, len(edgesTS) - 1)]
tic = time.clock()
if entire == True:
S = G
if alg == 'greedy':
if fast == True:
timeIntervals, edges_covered, usedB = greedy_speedup_log.greedy(
S, edgesTS, k, timeIntervals, B)
#timeIntervals, edges_covered, rest_B = greedy_emails.greedy(S, edgesTS, k, timeIntervals, B)
if fast == False:
timeIntervals, edges_covered, usedB = greedy_log.greedy(
S, edgesTS, k, timeIntervals, B)
#print timeIntervals, edges_covered, rest_B
if alg == 'binary':
if fast == True:
#timeIntervals, edges_covered, usedB = greedy_speedup.binary(S, edgesTS, k, timeIntervals, B)
timeIntervals, edges_covered, usedB = greedy_speedup_log.binary(
S, edgesTS, k, timeIntervals, B)
if fast == False:
#timeIntervals, edges_covered, usedB = greedy.binary(S, edgesTS, k, timeIntervals, B)
timeIntervals, edges_covered, usedB = greedy_log.binary(
S, edgesTS, k, timeIntervals, B)
if alg == 'dynprogr':
timeIntervals, edges_covered, usedB, D = dynprogr.dynprogr(
S, edgesTS, k, timeIntervals, B, n_disc)
#print timeIntervals, edges_covered, rest_B, D
#print timeIntervals, edges_covered, rest_B
#exit()
toc = time.clock()
# if fast == True:
# print 'fast interval search', toc-tic
# if fast == False:
# print 'basic interval search', toc-tic
if pics:
plotting.plotPoints(outpath, S, edgesTS, timeIntervals, counter, B,
rest_B, k, edges_covered)
counter += 1
if pics:
plotting.coveredSubgraphs(outpath, counter, edgesTS, timeIntervals,
edges_covered)
counter += 1
nodes_covered = set()
for i in edges_covered:
nodes_covered.add(i[0])
nodes_covered.add(i[1])
#e1 = set([set(i) for i in S.edges()])
#e2 = set([set(i) for i in edges_covered])
e1 = np.array(S.edges())
e1.sort(1)
e1 = map(tuple, e1)
#print e1
#print list(edges_covered)
e2 = np.array(list(edges_covered))
e2.sort(1)
e2 = map(tuple, e2)
#if (set(S.edges())).issubset(set(edges_covered)):
#print 2.0*S.number_of_edges()/S.number_of_nodes()
#print len(e1), len(e2)
if set(e1).issubset(set(e2)):
#if set(S.nodes()).issubset(set(nodes_covered)):
out = 2.0 * len(edges_covered) / len(nodes_covered)
# print edges_covered
# print ' '.join(map(str,nodes_covered))
# print 2.0*len(edges_covered)/len(nodes_covered), B, B-rest_B
# print baseAvg, baseInt, baseEdges, baseS.number_of_nodes()
# #print timeIntervals.keys()
# for i in timeIntervals:
# sys.stdout.write(str(i[0]) + ',' + str(i[1]) + ';')
# print ''
# for i in timeIntervals:
# sys.stdout.write(str(edgesTS[i[0]][0]) + ',' + str(edgesTS[i[1]][0]) + ';')
break
print toc - tic, out
sys.stdout.flush()
return out, baseAvg, nodes_covered
#alg = 'dynprogr'
#alg = 'greedy'
#alg = 'binary'
#charikar_version = 'basic'
charikar_version = 'fixed'
# if alg == 'greedy' or alg == 'binary':
# charikar_mode = 'unweighted'
# if alg == 'dynprogr':
# charikar_mode = 'weighted'
#k = 3
#B = timedelta(seconds = 20)
B = timedelta(days=b)
#n = 1000
edgesTS, nodes, edges = utils.readFile(filepath)
_, _, baseS = utils.getBaseline(edgesTS, B)
avg_base = 2.0 * baseS.number_of_edges() / baseS.number_of_nodes()
size_base = baseS.number_of_nodes()
ff = open(outpath, "a")
#ff.write(' '.join([str(gr_avg_best), str(bi_avg_best), str(dy_avg_best), str(gr_int_best), str(bi_int_best), str(dy_int_best),
#str(gr_size_best), str(bi_size_best), str(dy_size_best), '\n']))
ff.write(' '.join([str(avg_base), str(size_base), '\n']))
ff.close()
#print i1
#print i2
best_avg = []
best_intervals = []
initIntervals = [(0, len(edgesTS) - 1)]
edgesTSBi = copy.deepcopy(edgesTS)
edgesTSGr = copy.deepcopy(edgesTS)
#G = utils.getGraph(edgesTS)
for ind in xrange(0, comN):
baseAvg, baseInt, S = utils.getBaseline(edgesTS, B)
#S, avg_char = charikar.charikar(copy.deepcopy(G))
#G.remove_edges_from(S.edges())
#Sedges = S.edges()
Sedges = np.array(S.edges())
Sedges.sort(1)
Sedges = map(tuple, Sedges)
#minspanChar, _, _ = utils.shortestInt(edgesTS, Sedges)
#minspanChar = minspanChar.total_seconds()/(60*60*24.0)
T = []
#print len(edgesTSGr)
for i in edgesTS:
if i[1] not in Sedges:
T.append(i)
edgesTS = copy.deepcopy(T)