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)