/************************************************************************* * Let the game begin **************************************************************************/ int main(int argc, char *argv[]) { GraphType graph; char filename[256]; idxtype wgtflag; if (argc != 2) { mprintf("Usage: %s <GraphFile>\n", argv[0]); exit(0); } strcpy(filename, argv[1]); ReadGraph(&graph, filename, &wgtflag); if (graph.nvtxs == 0) { mprintf("Empty graph!\n"); exit(0); } mprintf("**********************************************************************\n"); mprintf("%s", METISTITLE); mprintf("Graph Information ---------------------------------------------------\n"); mprintf(" Name: %s, #Vertices: %D, #Edges: %D\n\n", filename, graph.nvtxs, graph.nedges/2); mprintf("Checking Graph... ---------------------------------------------------\n"); if (CheckGraph(&graph)) mprintf(" The format of the graph is correct!\n"); else mprintf(" The format of the graph is incorrect!\n"); mprintf("\n**********************************************************************\n"); gk_free((void **)&graph.xadj, &graph.adjncy, &graph.vwgt, &graph.adjwgt, LTERM); }
void ReadGraphAsymmErrors(const char *name, Int_t igr, Double_t *gx, Double_t *gy, Double_t *egy) { TFile *f = new TFile(name); TGraphAsymmErrors *gr = (TGraphAsymmErrors*)f->Get(Form("gr_%d",igr)); ReadGraph(gr, gx, gy, egy); f->Close(); return; }
int main(int argc, char **argv) { Graph *g1, *g2; LabelList *labelList = NULL; BOOLEAN directed = TRUE; // 'e' edges are considered directed ULONG maxVertices; VertexMap *mapping; double matchCost; if (argc != 3) { fprintf(stderr, "usage: %s <graph file> <graph file>\n", argv[0]); exit(1); } labelList = AllocateLabelList(); g1 = ReadGraph(argv[1], labelList, directed); g2 = ReadGraph(argv[2], labelList, directed); if (g1->numVertices < g2->numVertices) { maxVertices = g2->numVertices; mapping = (VertexMap *) malloc(sizeof(VertexMap) * maxVertices); matchCost = InexactGraphMatch(g2, g1, labelList, MAX_DOUBLE, mapping); } else { maxVertices = g1->numVertices; mapping = (VertexMap *) malloc(sizeof(VertexMap) * maxVertices); matchCost = InexactGraphMatch(g1, g2, labelList, MAX_DOUBLE, mapping); } printf("Match Cost = %f\n", matchCost); PrintMapping(mapping, maxVertices); free(mapping); return 0; }
/************************************************************************* * Let the game begin **************************************************************************/ int main(int argc, char *argv[]) { idx_t i; idx_t *perm, *iperm; graph_t *graph; params_t params; size_t maxlnz, opc; if (argc != 3) { printf("Usage: %s <GraphFile> <PermFile\n", argv[0]); exit(0); } params.filename = gk_strdup(argv[1]); graph = ReadGraph(¶ms); if (graph->nvtxs <= 0) { printf("Empty graph. Nothing to do.\n"); exit(0); } if (graph->ncon != 1) { printf("Ordering can only be applied to graphs with one constraint.\n"); exit(0); } /* Read the external iperm vector */ perm = imalloc(graph->nvtxs, "main: perm"); iperm = imalloc(graph->nvtxs, "main: iperm"); ReadPOVector(graph, argv[2], iperm); for (i=0; i<graph->nvtxs; i++) perm[iperm[i]] = i; printf("**********************************************************************\n"); printf("%s", METISTITLE); printf("Graph Information ---------------------------------------------------\n"); printf(" Name: %s, #Vertices: %"PRIDX", #Edges: %"PRIDX"\n\n", argv[1], graph->nvtxs, graph->nedges/2); printf("Fillin... -----------------------------------------------------------\n"); ComputeFillIn(graph, perm, iperm, &maxlnz, &opc); printf(" Nonzeros: %6.3le \tOperation Count: %6.3le\n", (double)maxlnz, (double)opc); printf("**********************************************************************\n"); FreeGraph(&graph); }
int main(int argc, char *argv[]) { graph_t *graph, *fgraph; char filename[256]; idx_t wgtflag; params_t params; if (argc != 2 && argc != 3) { printf("Usage: %s <GraphFile> [FixedGraphFile (for storing the fixed graph)]\n", argv[0]); exit(0); } memset((void *) ¶ms, 0, sizeof(params_t)); params.filename = gk_strdup(argv[1]); graph = ReadGraph(¶ms); if (graph->nvtxs == 0) { printf("Empty graph!\n"); exit(0); } printf("**********************************************************************\n"); printf("%s", METISTITLE); printf(" (HEAD: %s, Built on: %s, %s)\n", SVNINFO, __DATE__, __TIME__); printf(" size of idx_t: %zubits, real_t: %zubits, idx_t *: %zubits\n", 8 * sizeof(idx_t), 8 * sizeof(real_t), 8 * sizeof(idx_t * )); printf("\n"); printf("Graph Information ---------------------------------------------------\n"); printf(" Name: %s, #Vertices: %"PRIDX", #Edges: %"PRIDX"\n\n", params.filename, graph->nvtxs, graph->nedges / 2); printf("Checking Graph... ---------------------------------------------------\n"); if (CheckGraph(graph, 1, 1)) { printf(" The format of the graph is correct!\n"); } else { printf(" The format of the graph is incorrect!\n"); if (argc == 3) { fgraph = FixGraph(graph); WriteGraph(fgraph, argv[2]); FreeGraph(&fgraph); printf(" A corrected version was stored at %s\n", argv[2]); } } printf("\n**********************************************************************\n"); FreeGraph(&graph); gk_free((void **) ¶ms.filename, ¶ms.tpwgtsfile, ¶ms.tpwgts, LTERM); }
int main(int argc, char* argv[]) { TStr InFile,OutFile; int Dimensions, WalkLen, NumWalks, WinSize, Iter; double ParamP, ParamQ; bool Directed, Weighted, Verbose, OutputWalks; ParseArgs(argc, argv, InFile, OutFile, Dimensions, WalkLen, NumWalks, WinSize, Iter, Verbose, ParamP, ParamQ, Directed, Weighted, OutputWalks); PWNet InNet = PWNet::New(); TIntFltVH EmbeddingsHV; TVVec <TInt, int64> WalksVV; ReadGraph(InFile, Directed, Weighted, Verbose, InNet); node2vec(InNet, ParamP, ParamQ, Dimensions, WalkLen, NumWalks, WinSize, Iter, Verbose, OutputWalks, WalksVV, EmbeddingsHV); WriteOutput(OutFile, EmbeddingsHV, WalksVV, OutputWalks); return 0; }
/* initializeScheduler * Initializes scheduler if it has not been initialized yet. * Returns 0 if the scheduler was initialized correctly. * Returns 1 if the scheduler already exists. * Returns -1 if the initialization was unsuccessful. */ int initializeScheduler(void) { if(_Scheduler == NULL) { _Scheduler = (Scheduler*) malloc(sizeof(Scheduler)); if(_Scheduler == NULL) return -1; /* Set the Scheduler pointer to be shared */ #ifdef __APPLE__ _Scheduler = mmap(NULL, sizeof(_Scheduler), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0); #else _Scheduler = mmap(NULL, sizeof(_Scheduler), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); #endif /* Initialize fields */ _Scheduler->counterExamples = new_dllist(); _Scheduler->listSize = 0; /* Load best graph counterexamples */ int file_count; char **CEfiles = getCounterExamplesFromFolder("../../../counterexamples/more121", &file_count); int i; for(i = 0; i < file_count; i++) { int *g; char *fname; asprintf(&fname, "../../../counterexamples/more121/%s", CEfiles[i]); if(ReadGraph(fname, &g, &(_Scheduler->currCEsize))) { fprintf(stderr, "Loaded graph %s successfully!\n", fname); addCounterExample(g); } } /*Print list size*/ fprintf(stderr, "List size after initialization: %d\n", _Scheduler->listSize); /* Initialize current list pointer */ _Scheduler->currPtr = dll_first(_Scheduler->counterExamples); /* free CEfiles */ for(i = 0; i < _Scheduler->listSize; i++) { free(CEfiles[i]); } free(CEfiles); return 0; } else return 1; }
void Read(const QString& fileName, SignalData& data, PlotInfo& plotInfo, std::function<void(Signal&&)> onSignal, std::function<void()> onAfterSignalRead) { QFile in(fileName); if (!in.open(QIODevice::ReadOnly | QFile::Text)) { auto mex = QString("Cannot open specified file -> %1").arg(fileName); QMessageBox::critical(nullptr, "Anvedi", mex); throw std::exception(mex.toUtf8().data()); } const auto json = QJsonDocument::fromJson(in.readAll()).object(); auto backgroundIt = json.find("background"); if (backgroundIt != json.end()) { plotInfo.setBackgroundColor(backgroundIt->toString()); } auto graphIt = json.find("signals"); if ((graphIt != json.end()) && graphIt->isArray()) { for (const auto& elem : graphIt->toArray()) { if (elem.isObject()) { onSignal(ReadGraph(elem.toObject())); } } } onAfterSignalRead(); auto domainIt = json.find("domain"); if (domainIt != json.end()) { const auto domainName = domainIt->toString(); try { data.setAsDomain(domainName); } catch (const std::exception&){} } }
void draw_BR() { gROOT->ProcessLine(".L ReadGraph.C"); TFile *f = new TFile("particles.root"); TH2 *h2_particles = (TH2*)f->Get("h2_particles"); TH1* h_others = h2_particles->ProjectionX("h_others", 2, 3); TH1* h_pion = h2_particles->ProjectionX("h_pion", 1, 1); TCanvas *c = new TCanvas("c", "Canvas", 600, 600); gStyle->SetOptStat(0); TGraphAsymmErrors *gr = new TGraphAsymmErrors(h_others, h_pion); gr->SetTitle("Two photons acceptance"); gr->GetXaxis()->SetTitle("p_{T} [GeV]"); gr->GetYaxis()->SetTitle("#frac{#eta+#omega}{#pi^{0}}"); gr->GetXaxis()->SetRangeUser(0., 12.); gr->GetYaxis()->SetRangeUser(0., 0.5); gr->Draw("AP"); c->Print("BR.pdf"); Double_t gx[30], gy[30], egy[30]; ReadGraph(gr, gx, gy, egy); Double_t nothers = h_others->Integral(11,30); Double_t npion = h_pion->Integral(11,30); Double_t BRbar = nothers / npion; Double_t eBRbar = BRbar * sqrt( 1./nothers + 1./npion ); for(Int_t ipt=10; ipt<30; ipt++) { gy[ipt] = BRbar; egy[ipt] = eBRbar; } TGraphErrors *grout = new TGraphErrors(30, gx, gy, 0, egy); grout->SetName("gr_0"); TFile *fout = new TFile("BR.root", "RECREATE"); grout->Write(); fout->Close(); }
int main(int argc, char *argv[]) { int i, npart; idxtype *part; float ncut=0; GraphType graph; char filename[256],outputFile[256]; int wgtflag = 0, addSelfLoop=1, outputFileGiven=0, txtFormat=0 ; int randomInit = 0; idxtype minEdgeWeight = 0; Options opt; timer TOTALTmr, METISTmr, IOTmr; initOptions(&opt); if (argc < 2) { print_help(argv[0]); exit(0); } for (argv++; *argv != NULL; argv++){ if ((*argv)[0] == '-') { int temp; switch ((*argv)[1]) { case 'b': case 'B': opt.penalty_power=atof(*(++argv)); break; case 'i': case 'I': opt.gamma=atof(*(++argv)); break; case 'o': case 'O': strcpy(outputFile,*(++argv)); outputFileGiven=1; break; case 'D'://quality threshold. This is a post-processing step proposed in SR-MCL. If you dont want post-processing (this is what original MLR-MCL, R-MCL, MCL do, please set "-d 0" case 'd': opt.quality_threshold = atof(*(++argv)); break; case 'w': case 'W': opt.weighted_density = true; break; case 'c': case 'C': opt.coarsenTo= atoi(*(++argv)); break; default: printf("Invalid option %s\n", *argv); print_help(argv[0]); exit(0); } } else { strcpy(filename, *argv); } } if ( randomInit > 0 ) InitRandom(time(NULL)); else InitRandom(-1); cleartimer(TOTALTmr); cleartimer(METISTmr); cleartimer(IOTmr); starttimer(TOTALTmr); starttimer(IOTmr); ReadGraph(&graph, filename, &wgtflag, addSelfLoop, txtFormat); if ( opt.matchType == MATCH_UNSPECIFIED ) { // opt.matchType = (graph.nvtxs>50000) ? MATCH_POWERLAW_FC : // MATCH_SHEMN; opt.matchType = MATCH_SHEMN; } stoptimer(IOTmr); if (graph.nvtxs <= 0) { printf("Empty graph. Nothing to do.\n"); exit(0); } int noOfSingletons = 0; GraphType *noSingletonGraph ; idxtype* nodeMap = lookForSingletons(&graph, &noOfSingletons); if ( noOfSingletons > 0 ) { getSubgraph(&graph, nodeMap, graph.nvtxs-noOfSingletons, wgtflag, &noSingletonGraph); GKfree((void**)&(graph.xadj), (void**)&(graph.adjncy), LTERM); if ( wgtflag&1 > 0 ) GKfree( (void**)&(graph.adjwgt), LTERM); // free(graph.gdata); printf("Found %d singleton nodes in the", noOfSingletons); printf(" input graph. Removing them.\n"); } if ( !outputFileGiven ) { strcpy(outputFile, filename); sprintf(outputFile,"%s.c%d.i%1.1f.b%1.1f",outputFile,opt.coarsenTo,opt.gamma,opt.penalty_power); } printf("Input graph information ---------------------------------------------------\n"); printf(" Name: %s, #Vertices: %d, #Edges: %d\n", filename, graph.nvtxs, graph.nedges/2); printf("Output shall be placed in the file %s\n", outputFile); fflush(stdout); part = idxmalloc(graph.nvtxs, "main: part"); printf("------------------------------------------------\n"); printf("Clustering....\n"); fflush(stdout); starttimer(METISTmr); //YK: main algorithm starts here! if ( noOfSingletons > 0 ) { mlmcl(&(noSingletonGraph->nvtxs), noSingletonGraph->xadj, noSingletonGraph->adjncy, noSingletonGraph->vwgt,noSingletonGraph->adjwgt, &wgtflag, part, opt ); } else { mlmcl(&graph.nvtxs, graph.xadj, graph.adjncy,graph.vwgt, graph.adjwgt, &wgtflag, part, opt ); } stoptimer(METISTmr); printf("------------------------------------------------\n"); if ( noOfSingletons > 0 ) { npart=mapPartition(part,noSingletonGraph->nvtxs); ncut=ComputeNCut(noSingletonGraph, part,npart); // printf("In graph that does not include singletons,"); // printf("No. of Clusters: %d, N-Cut value: %.2f\n",npart,ncut); idxtype *clusterSizes = histogram(part, graph.nvtxs-noOfSingletons, npart); int maxSize = clusterSizes[idxamax(npart, clusterSizes)]; float avgClusterSize = (graph.nvtxs-noOfSingletons)*1.0/(npart); float balance = (maxSize*1.0) / ((graph.nvtxs-noOfSingletons)*1.0/npart); float stdDevn = stdDeviation(clusterSizes, npart); float avgNcut = ncut * 1.0/npart; float normStdDevn = stdDevn/avgClusterSize; // Warning: This computation only works if the singletons // have been placed in their own clusters. This works for // MLR-MCL, in other words, because it is guaranteed to // place singletons in their own clusters. printf("Output statistics for graph without singletons\n"); printf("Clusters: %d N-Cut: %.3f", npart, ncut); printf(" AvgN-Cut: %.3f Balance in cluster sizes: %.2f ",avgNcut, balance); printf("Std_Deviation in cluster sizes: %.2f ", stdDevn); printf("Coefficient_of_Variation: %.2f\n", normStdDevn); free( clusterSizes ); npart += noOfSingletons; // ncut += noOfSingletons; printf("Output statistics for original graph\n"); mapIndices(part, nodeMap, graph.nvtxs, npart-noOfSingletons); } else { npart=mapPartition(part,graph.nvtxs); ncut=ComputeNCut(&graph, part,npart); } idxtype* clusterSizes = histogram(part, graph.nvtxs, npart); int maxSize = clusterSizes[idxamax(npart, clusterSizes)]; float avgClusterSize = (graph.nvtxs)*1.0/(npart); float balance = (maxSize*1.0)/(graph.nvtxs*1.0/npart); float stdDevn = stdDeviation(clusterSizes, npart); float avgNcut = ncut * 1.0/npart; float normStdDevn = stdDevn/avgClusterSize; printf("Clusters: %d N-Cut: %.3f AvgN-Cut: %.3f", npart, ncut, avgNcut ); printf(" Balance in cluster sizes: %.2f Std.Deviation in cluster sizes: %.2f ", balance, stdDevn); printf("Coefficient_of_Variation: %.2f\n", normStdDevn); starttimer(IOTmr); my_WritePartition(outputFile, part, graph.nvtxs, opt.gamma); if ( noOfSingletons > 0 ) { free(nodeMap); nodeMap = NULL; } printf("\nOutput is written to file: %s\n", outputFile); stoptimer(IOTmr); stoptimer(TOTALTmr); printf("\nTiming Information --------------------------------------------------\n"); printf(" I/O: \t\t %7.3f\n", gettimer(IOTmr)); printf(" Partitioning: \t\t %7.3f (MLR-MCL time)\n", gettimer(METISTmr)); printf(" Total: \t\t %7.3f\n", gettimer(TOTALTmr)); printf("**********************************************************************\n"); GKfree((void**)&graph.xadj, (void**)&graph.adjncy, (void**)&graph.vwgt, (void**)&graph.adjwgt, (void**)&part, LTERM); }
int main(int argc,char *argv[]) { int *g; int *new_g; int gsize; int count; int i; int j; int best_count; int best_i; int best_j; int best_x; int best_y; void *taboo_list; srand (time(NULL)); /* * start with graph of size 8 */ gsize = 54; g = (int *)malloc(gsize*gsize*sizeof(int)); if(g == NULL) { exit(1); } /* * make a fifo to use as the taboo list */ taboo_list = FIFOInitEdge(TABOOSIZE); if(taboo_list == NULL) { exit(1); } /* * start out with all zeros */ memset(g,0,gsize*gsize*sizeof(int)); ReadGraph(g,gsize); /* int ns=gsize+10; new_g = (int *)malloc((ns)*(ns)*sizeof(int)); //CopyGraph(g,gsize,new_g,ns); GoodCopy(g,gsize,new_g,ns); PrintGraph(new_g,ns); count = CliqueCount(new_g,ns); printf("%d\n",count); return ; */ /* * while we do not have a publishable result */ int flag=1; int lastcount=IMAX; while(gsize < 102) { /* * find out how we are doing */ count = CliqueCount(g,gsize); /* * if we have a counter example */ if(count == 0) { printf("Eureka! Counter-example found!\n"); PrintGraph(g,gsize); WriteGraph(g,gsize); /* * make a new graph one size bigger */ new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int)); if(new_g == NULL) exit(1); /* * copy the old graph into the new graph leaving the * last row and last column alone */ //CopyGraph(g,gsize,new_g,gsize+1); GoodCopy(g,gsize,new_g,gsize+1); /* * zero out the last column and last row for(i=0; i < (gsize+1); i++) { new_g[i*(gsize+1) + gsize] = 0; // last column new_g[gsize*(gsize+1) + i] = 0; // last row } */ /* * throw away the old graph and make new one the * graph */ free(g); g = new_g; gsize = gsize+1; /* * reset the taboo list for the new graph */ taboo_list = FIFOResetEdge(taboo_list); /* * keep going */ continue; } /* * otherwise, we need to consider flipping an edge * * let's speculative flip each edge, record the new count, * and unflip the edge. We'll then remember the best flip and * keep it next time around * * only need to work with upper triangle of matrix => * notice the indices */ int x,y; best_count = BIGCOUNT; for(x=0; x < gsize*gsize; x++) { for(y=x; y < gsize*gsize; y++) { if(y%gsize < x%gsize) continue; // swap if(g[x]==g[y] && x!=y) continue; swap(g,x,y); count = CliqueCount(g,gsize); // * is it better and the i,j,count not taboo? if((count < best_count) && !FIFOFindEdge(taboo_list,x,y)) // !FIFOFindEdgeCount(taboo_list,i,j,count)) { best_count = count; best_x = x; best_y = y; } // * flip it back swap(g,x,y); } } /* best_count = BIGCOUNT; for(i=0; i < gsize; i++) { for(j=i+1; j < gsize; j++) { // flip it g[i*gsize+j] = 1 - g[i*gsize+j]; count = CliqueCount(g,gsize); // * is it better and the i,j,count not taboo? if((count < best_count) && !FIFOFindEdge(taboo_list,i,j)) // !FIFOFindEdgeCount(taboo_list,i,j,count)) { best_count = count; best_i = i; best_j = j; } // * flip it back g[i*gsize+j] = 1 - g[i*gsize+j]; } } */ if(best_count == BIGCOUNT) { printf("no best edge found, terminating\n"); exit(1); } /* * keep the best flip we saw */ //g[best_i*gsize+best_j] = 1 - g[best_i*gsize+best_j]; swap(g,best_x,best_y); /* * taboo this graph configuration so that we don't visit * it again */ count = CliqueCount(g,gsize); // FIFOInsertEdge(taboo_list,best_i,best_j); FIFOInsertEdgeCount(taboo_list,best_i,best_j,count); // FIFOInsertEdge(taboo_list,best_x,best_y); /* printf("ce size: %d, best_count: %d, swap: (%d,%d)\n", gsize, best_count, best_x, best_y ); */ /* printf("ce size: %d, best_count: %d, best edge: (%d,%d), new color: %d\n", gsize, best_count, best_i, best_j, g[best_i*gsize+best_j]); */ /* * rinse and repeat */ } FIFODeleteGraph(taboo_list); return(0); }
/************************************************************************* * Let the game begin **************************************************************************/ main(int argc, char *argv[]) { int i, options[10]; idxtype *perm, *iperm; GraphType graph; char filename[256]; int numflag = 0, wgtflag; timer TOTALTmr, METISTmr, IOTmr, SMBTmr; if (argc != 2) { printf("Usage: %s <GraphFile>\n",argv[0]); exit(0); } strcpy(filename, argv[1]); cleartimer(TOTALTmr); cleartimer(METISTmr); cleartimer(IOTmr); cleartimer(SMBTmr); starttimer(TOTALTmr); starttimer(IOTmr); ReadGraph(&graph, filename, &wgtflag); if (graph.nvtxs <= 0) { printf("Empty graph. Nothing to do.\n"); exit(0); } if (graph.ncon != 1) { printf("Ordering can only be applied to graphs with one constraint.\n"); exit(0); } stoptimer(IOTmr); /* Ordering does not use weights! */ GKfree(&graph.vwgt, &graph.adjwgt, LTERM); printf("**********************************************************************\n"); printf("%s", METISTITLE); printf("Graph Information ---------------------------------------------------\n"); printf(" Name: %s, #Vertices: %d, #Edges: %d\n\n", filename, graph.nvtxs, graph.nedges/2); printf("Node-Based Ordering... ----------------------------------------------\n"); perm = idxmalloc(graph.nvtxs, "main: perm"); iperm = idxmalloc(graph.nvtxs, "main: iperm"); options[0] = 0; starttimer(METISTmr); METIS_NodeND(&graph.nvtxs, graph.xadj, graph.adjncy, &numflag, options, perm, iperm); stoptimer(METISTmr); starttimer(IOTmr); WritePermutation(filename, iperm, graph.nvtxs); stoptimer(IOTmr); starttimer(SMBTmr); ComputeFillIn(&graph, iperm); stoptimer(SMBTmr); stoptimer(TOTALTmr); printf("\nTiming Information --------------------------------------------------\n"); printf(" I/O: \t %7.3f\n", gettimer(IOTmr)); printf(" Ordering: \t %7.3f (ONMETIS time)\n", gettimer(METISTmr)); printf(" Symbolic Factorization: \t %7.3f\n", gettimer(SMBTmr)); printf(" Total: \t %7.3f\n", gettimer(TOTALTmr)); printf("**********************************************************************\n"); GKfree(&graph.xadj, &graph.adjncy, &perm, &iperm, LTERM); }
/************************************************************************* * Let the game begin **************************************************************************/ main(int argc, char *argv[]) { int i, nparts, options[10]; idxtype *part; float rubvec[MAXNCON], lbvec[MAXNCON]; GraphType graph; char filename[256]; int numflag = 0, wgtflag = 0, edgecut; timer TOTALTmr, METISTmr, IOTmr; if (argc != 3) { printf("Usage: %s <GraphFile> <Nparts>\n",argv[0]); exit(0); } strcpy(filename, argv[1]); nparts = atoi(argv[2]); if (nparts < 2) { printf("The number of partitions should be greater than 1!\n"); exit(0); } cleartimer(TOTALTmr); cleartimer(METISTmr); cleartimer(IOTmr); starttimer(TOTALTmr); starttimer(IOTmr); ReadGraph(&graph, filename, &wgtflag); if (graph.nvtxs <= 0) { printf("Empty graph. Nothing to do.\n"); exit(0); } stoptimer(IOTmr); printf("**********************************************************************\n"); printf("%s", METISTITLE); printf("Graph Information ---------------------------------------------------\n"); printf(" Name: %s, #Vertices: %d, #Edges: %d, #Parts: %d\n", filename, graph.nvtxs, graph.nedges/2, nparts); if (graph.ncon > 1) printf(" Balancing Constraints: %d\n", graph.ncon); printf("\nK-way Partitioning... -----------------------------------------------\n"); part = idxmalloc(graph.nvtxs, "main: part"); options[0] = 0; starttimer(METISTmr); if (graph.ncon == 1) { METIS_PartGraphKway(&graph.nvtxs, graph.xadj, graph.adjncy, graph.vwgt, graph.adjwgt, &wgtflag, &numflag, &nparts, options, &edgecut, part); } else { for (i=0; i<graph.ncon; i++) rubvec[i] = HORIZONTAL_IMBALANCE; METIS_mCPartGraphKway(&graph.nvtxs, &graph.ncon, graph.xadj, graph.adjncy, graph.vwgt, graph.adjwgt, &wgtflag, &numflag, &nparts, rubvec, options, &edgecut, part); } stoptimer(METISTmr); ComputePartitionBalance(&graph, nparts, part, lbvec); printf(" %d-way Edge-Cut: %7d, Balance: ", nparts, edgecut); for (i=0; i<graph.ncon; i++) printf("%5.2f ", lbvec[i]); printf("\n"); starttimer(IOTmr); WritePartition(filename, part, graph.nvtxs, nparts); stoptimer(IOTmr); stoptimer(TOTALTmr); printf("\nTiming Information --------------------------------------------------\n"); printf(" I/O: \t\t %7.3f\n", gettimer(IOTmr)); printf(" Partitioning: \t\t %7.3f (KMETIS time)\n", gettimer(METISTmr)); printf(" Total: \t\t %7.3f\n", gettimer(TOTALTmr)); printf("**********************************************************************\n"); GKfree(&graph.xadj, &graph.adjncy, &graph.vwgt, &graph.adjwgt, &part, LTERM); }
idx_t* gpmetis( int argc, char **argv ) /*************************************************************************/ /*! Let the game begin! */ /*************************************************************************/ //int main(int argc, char *argv[]) { idx_t i; char *curptr, *newptr; idx_t options[METIS_NOPTIONS]; graph_t *graph; idx_t *part; idx_t objval; params_t *params; int status=0; gk_optind = 0; //printf( "argc: %d\n", argc ); //printf( "gk_optind %d\n", gk_optind ); fflush( stdout ); for( i = 0; i < argc; i++ ) { //printf( "%s*\n", argv[ i ] ); } params = parse_cmdline(argc, argv); //printf( "gk_optind %d\n", gk_optind ); //fflush( stdout ); //return NULL; gk_startcputimer(params->iotimer); graph = ReadGraph(params); ReadTPwgts(params, graph->ncon); gk_stopcputimer(params->iotimer); /* Check if the graph is contiguous */ if (params->contig && !IsConnected(graph, 0)) { printf("***The input graph is not contiguous.\n" "***The specified -contig option will be ignored.\n"); params->contig = 0; } /* Get ubvec if supplied */ if (params->ubvecstr) { params->ubvec = rmalloc(graph->ncon, "main"); curptr = params->ubvecstr; for (i=0; i<graph->ncon; i++) { params->ubvec[i] = strtoreal(curptr, &newptr); if (curptr == newptr) errexit("Error parsing entry #%"PRIDX" of ubvec [%s] (possibly missing).\n", i, params->ubvecstr); curptr = newptr; } } /* Setup iptype */ if (params->iptype == -1) { if (params->ptype == METIS_PTYPE_RB) { if (graph->ncon == 1) params->iptype = METIS_IPTYPE_GROW; else params->iptype = METIS_IPTYPE_RANDOM; } } GPPrintInfo(params, graph); part = imalloc(graph->nvtxs, "main: part"); METIS_SetDefaultOptions(options); options[METIS_OPTION_OBJTYPE] = params->objtype; options[METIS_OPTION_CTYPE] = params->ctype; options[METIS_OPTION_IPTYPE] = params->iptype; options[METIS_OPTION_RTYPE] = params->rtype; options[METIS_OPTION_MINCONN] = params->minconn; options[METIS_OPTION_CONTIG] = params->contig; options[METIS_OPTION_SEED] = params->seed; options[METIS_OPTION_NITER] = params->niter; options[METIS_OPTION_NCUTS] = params->ncuts; options[METIS_OPTION_UFACTOR] = params->ufactor; options[METIS_OPTION_DBGLVL] = params->dbglvl; gk_malloc_init(); gk_startcputimer(params->parttimer); switch (params->ptype) { case METIS_PTYPE_RB: status = METIS_PartGraphRecursive(&graph->nvtxs, &graph->ncon, graph->xadj, graph->adjncy, graph->vwgt, graph->vsize, graph->adjwgt, ¶ms->nparts, params->tpwgts, params->ubvec, options, &objval, part); break; case METIS_PTYPE_KWAY: status = METIS_PartGraphKway(&graph->nvtxs, &graph->ncon, graph->xadj, graph->adjncy, graph->vwgt, graph->vsize, graph->adjwgt, ¶ms->nparts, params->tpwgts, params->ubvec, options, &objval, part); break; } gk_stopcputimer(params->parttimer); if (gk_GetCurMemoryUsed() != 0) printf("***It seems that Metis did not free all of its memory! Report this.\n"); params->maxmemory = gk_GetMaxMemoryUsed(); gk_malloc_cleanup(0); if (status != METIS_OK) { printf("\n***Metis returned with an error.\n"); } else { if (!params->nooutput) { /* Write the solution */ gk_startcputimer(params->iotimer); WritePartition(params->filename, part, graph->nvtxs, params->nparts); gk_stopcputimer(params->iotimer); } GPReportResults(params, graph, part, objval); } idx_t *r_part = ( idx_t* ) calloc( graph->nvtxs, sizeof( idx_t ) ); for( i = 0; i < graph->nvtxs; i++ ) { r_part[ i ] = part[ i ]; } FreeGraph(&graph); gk_free((void **)&part, LTERM); gk_free((void **)¶ms->filename, ¶ms->tpwgtsfile, ¶ms->tpwgts, ¶ms->ubvecstr, ¶ms->ubvec, ¶ms, LTERM); return r_part; }
int main(int argc,char *argv[]) { signal(SIGINT, sig_handler); signal(SIGTERM, sig_handler); int *g; int *new_g; int gsize; long count; long count_1; long count_2; long count_3; int i; int j; int k; long best_count; long prev_best_count; int best_i; int best_j; int best_k; int best_l; void *taboo_list; int* taboo_array; int val,iter,jter; int multi = 0; /* * start with graph of size 8 */ if (argc < 2) { gsize = 8; g = (int *)malloc(gsize*gsize*sizeof(int)); if(g == NULL) { exit(1); } /* * start out with all zeros */ memset(g,0,gsize*gsize*sizeof(int)); val = 0, iter = 0, jter=0; for( iter=0; iter<gsize; iter++){ for( jter = 0; jter< gsize; jter++){ g[iter*gsize + jter] = val; val = 1 - val; } } PrintGraph(g, gsize); } else if (argc == 2) { gsize = atoi(argv[1]); g = (int *)malloc(gsize*gsize*sizeof(int)); if(g == NULL) { exit(1); } g = PaleyGraph(gsize); int* row = (int *)malloc(gsize*sizeof(int)); memcpy(row, g, gsize*sizeof(int)); create_sgraph(&g, gsize, row); taboo_array = (int*)malloc(sizeof(int)*gsize); memset(taboo_array, 0, gsize*sizeof(int)); printf("Starting from Paley graph of size %d\n.", gsize); fflush(stdout); free(row); } else { gsize = atoi(argv[1]); g = (int *)malloc(gsize*gsize*sizeof(int)); ReadGraph(argv[2], &g, &gsize); count = CliqueCount(g,gsize); if (count == 0) { printf("Eureka! Sym Counter-example found!\n"); PrintGraph(g,gsize); fflush(stdout); new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int)); if(new_g == NULL) exit(1); int* row = (int *)malloc((gsize+1)*sizeof(int)); memcpy(row, g, gsize*sizeof(int)); free(g); gsize = gsize+1; create_sgraph(&new_g, gsize, row); free(row); //CopyGraph(g,gsize,new_g,gsize+1); set_sedge(&new_g, gsize, gsize-1, 0); long count0 = CliqueCount(new_g, gsize); set_sedge(&new_g, gsize, gsize-1, 1); long count1 = CliqueCount(new_g, gsize); if(count0 < count1) set_sedge(&new_g, gsize, gsize-1, 0); taboo_array = (int*) malloc(sizeof(int)*gsize); memset(taboo_array, 0, sizeof(int)*gsize); g = new_g; } else { int* row = (int *)malloc(gsize*sizeof(int)); memcpy(row, g, gsize*sizeof(int)); create_sgraph(&g, gsize, row); taboo_array = (int*)malloc(sizeof(int)*gsize); memset(taboo_array, 0, gsize*sizeof(int)); printf("Starting from given graph of size %d\n.", gsize); fflush(stdout); free(row); } } /* *make a fifo to use as the taboo list */ taboo_list = FIFOInitEdge(TABOOSIZE); if(taboo_list == NULL) { exit(1); } /* * while we do not have a publishable result */ while(gsize<206) { best_count = BIGCOUNT; while(gsize < 206) { best_j = -1; count = CliqueCount(g,gsize); if(count == 0) { printf("Eureka! Sym Counter-example found!\n"); PrintGraph(g,gsize); fflush(stdout); /* * make a new graph one size bigger */ new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int)); if(new_g == NULL) exit(1); int* row = (int *)malloc((gsize+1)*sizeof(int)); memcpy(row, g, gsize*sizeof(int)); free(g); gsize = gsize+1; create_sgraph(&new_g, gsize, row); free(row); //CopyGraph(g,gsize,new_g,gsize+1); set_sedge(&new_g, gsize, gsize-1, 0); long count0 = CliqueCount(new_g, gsize); set_sedge(&new_g, gsize, gsize-1, 1); long count1 = CliqueCount(new_g, gsize); if(count0 < count1) set_sedge(&new_g, gsize, gsize-1, 0); taboo_array = (int*) malloc(sizeof(int)*gsize); memset(taboo_array, 0, sizeof(int)*gsize); g = new_g; best_count = BIGCOUNT; /* * reset the taboo list for the new graph */ //taboo_list = FIFOResetEdge(taboo_list); free(taboo_array); taboo_array = (int*) malloc(sizeof(int)*gsize); memset(taboo_array, 0, sizeof(int)*gsize); continue; } //best_count = BIGCOUNT; prev_best_count = best_count; if(multi<5){ for(i=0; i < gsize; i++) { flip_sedge(&g, gsize, i); count = CliqueCount(g,gsize); if(count<best_count && !taboo_array[i]){ //if(count<best_count ){ best_count = count; best_i = i; } flip_sedge(&g, gsize, i); } } else{ for(i=0; i<gsize; i++){ for(j=i+1; j<gsize; j++){ flip_sedge(&g, gsize, i); flip_sedge(&g, gsize, j); count = CliqueCount(g,gsize); if(count<best_count){ best_count = count; best_i = i; best_j = j; } flip_sedge(&g, gsize, i); flip_sedge(&g, gsize, j); } } } if(best_count == BIGCOUNT || best_count==prev_best_count) { if(multi>=5) { printf("no best edge found, continuing with taboo\n"); fflush(stdout); break; } else { printf("single flip exhausted. starting singleflip again.", multi); fflush(stdout); memset(taboo_array, 0, sizeof(int)*gsize); multi ++; continue; } //flip_sedge(g, gsize, i); } flip_sedge(&g, gsize, best_i); count = best_count; if(multi) flip_sedge(&g, gsize, best_j); taboo_array[best_i] = 1; printf("sym ce size: %d, best_count: %ld, best edge(s): (%d), (%d)\n", gsize, best_count, best_i, best_j); g_latest = g; g_size_latest = gsize; g_count_latest = count; fflush(stdout); } while(gsize < 206) { /* * if we have a counter example */ if(count == 0) { printf("Eureka! Counter-example found!\n"); PrintGraph(g,gsize); fflush(stdout); /* * make a new graph one size bigger */ new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int)); if(new_g == NULL) exit(1); /* * copy the old graph into the new graph leaving the * last row and last column alone */ CopyGraph(g,gsize,new_g,gsize+1); /* * zero out the last column and last row */ for(i=0; i < (gsize+1); i++) { if(drand48() > 0.5) { new_g[i*(gsize+1) + gsize] = 0; // last column new_g[gsize*(gsize+1) + i] = 0; // last row } else { new_g[i*(gsize+1) + gsize] = 1; // last column new_g[gsize*(gsize+1) + i] = 1; // last row } } /* * throw away the old graph and make new one the * graph */ free(g); g = new_g; gsize = gsize+1; /* * reset the taboo list for the new graph */ taboo_list = FIFOResetEdge(taboo_list); /* * keep going */ //continue; break; //Go to first while loop } /* * otherwise, we need to consider flipping an edge * * let's speculative flip each edge, record the new count, * and unflip the edge. We'll then remember the best flip and * keep it next time around * * only need to work with upper triangle of matrix => * notice the indices */ best_count = BIGCOUNT; for(i=0; i < gsize; i++) { for(j=i+1; j < gsize; j++) { /* * flip two edges (i,j), (i,random(j) + 1) */ int k = getRandomJ(gsize); int l = getRandomJ(gsize); g[i*gsize+j] = 1 - g[i*gsize+j]; count_1 = CliqueCount(g,gsize); if (k == j) k = j + 1; g[i*gsize + k] = 1 - g[i*gsize + k]; count_2 = CliqueCount(g,gsize); if (l == j) l = j + 1; if (l == k) l = (k + 1) % gsize; g[i*gsize + l] = 1 - g[i*gsize + l]; count_3 = CliqueCount(g,gsize); count = (count_1 < count_2) ? count_1 : count_2 ; count = (count_3 < count) ? count_3 : count ; /* * is it better and the i,j,count not taboo? */ if(count < best_count){ if(count == count_1 //#ifdef USE_TABOO && !FIFOFindEdgeCount(taboo_list,i,j,count) //#endif ) { best_count = count; best_i = i; best_j = j; best_k = best_l = -1; } else if(count == count_2 //#ifdef USE_TABOO && (!FIFOFindEdgeCount(taboo_list,i,j,count) || !FIFOFindEdgeCount(taboo_list,i,k, count)) //#endif ) { best_count = count; best_i = i; best_j = j; best_k = k; best_l = -1; } else if(count == count_3 //#ifdef USE_TABOO && (!FIFOFindEdgeCount(taboo_list,i,j,count) || !FIFOFindEdgeCount(taboo_list,i,k, count) || !FIFOFindEdgeCount(taboo_list,i,l, count)) //#endif ) { best_count = count; best_i = i; best_j = j; best_k = k; best_l = l; } } /* * flip it back */ g[i*gsize+j] = 1 - g[i*gsize+j]; g[i*gsize+k] = 1 - g[i*gsize+k]; g[i*gsize+l] = 1 - g[i*gsize+l]; } } if(best_count == BIGCOUNT) { printf("no best edge found, terminating\n"); exit(1); } /* * keep the best flip we saw */ g[best_i*gsize + best_j] = 1 - g[best_i*gsize + best_j]; if (best_k != -1) g[best_i*gsize + best_k] = 1 - g[best_i*gsize + best_k]; if (best_l != -1) g[best_i*gsize + best_l] = 1 - g[best_i*gsize + best_l]; /* * taboo this graph configuration so that we don't visit * it again */ //count = CliqueCount(g,gsize); count = best_count; //#ifdef USE_TABOO // FIFOInsertEdge(taboo_list,best_i,best_j); FIFOInsertEdgeCount(taboo_list,best_i,best_j,count); if (best_k != -1) FIFOInsertEdgeCount(taboo_list,best_i,best_k,count); if (best_l != -1) FIFOInsertEdgeCount(taboo_list,best_i,best_l,count); //#endif printf("ce size: %d, best_count: %ld, best edges: (%d,%d) (%d,%d) (%d,%d), new colors: %d %d\n", gsize, best_count, best_i, best_j, best_i, best_k, best_i, best_l, g[best_i*gsize+best_j], g[best_i*gsize+best_k]); fflush(stdout); g_latest = g; g_size_latest = gsize; g_count_latest = count; /* * rinse and repeat */ } } FIFODeleteGraph(taboo_list); return(0); }
/************************************************************************* * multi-level weighted kernel k-means main function **************************************************************************/ Graclus normalizedCut(char* filename, int nparts) { Graclus ncData; int options[11]; idxtype *part; // cluster result stored in array part float rubvec[MAXNCON], lbvec[MAXNCON]; GraphType graph; int numflag = 0, wgtflag = 0, edgecut, chain_length = 0; int no_args = 1, levels = 0; no_args = 0; if (nparts < 2) { printf("The number of partitions should be greater than 1!\n"); exit(0); } ReadGraph(&graph, filename, &wgtflag); if (graph.nvtxs <= 0) { puts("Empty graph. Nothing to do.\n"); exit(0); } levels = amax((graph.nvtxs)/(40*log2_metis(nparts)), 20*(nparts)); // if(graph.ncon > 1) // printf(" Balancing Constraints: %d\n", graph.ncon); part = idxmalloc(graph.nvtxs, "main: part"); options[0] = 0; // printf("#Clusters: %d\n", nparts); if (graph.ncon == 1) { MLKKM_PartGraphKway(&graph.nvtxs, graph.xadj, graph.adjncy, graph.vwgt, graph.adjwgt, &wgtflag, &numflag, &nparts, &chain_length, options, &edgecut, part, levels); } else { int i; for (i = 0; i < graph.ncon; i++) rubvec[i] = HORIZONTAL_IMBALANCE; } ComputePartitionBalance(&graph, nparts, part, lbvec); ComputeNCut(&graph, part, nparts); //for(int i = 0; i < graph.nvtxs; i++) printf("%d\n", part[i]); //int clusterNum = graph.nvtxs; ncData.part = part; ncData.clusterNum = graph.nvtxs; //GKfree((void **) &graph.xadj, (void **) &graph.adjncy, (void **) &graph.vwgt, (void **) &graph.adjwgt, (void **) &part, LTERM); GKfree((void **) &graph.xadj, (void **) &graph.adjncy, (void **) &graph.vwgt, (void **) &graph.adjwgt, LTERM); return ncData; }
int main() { Set<nodeT *> graph; Map<nodeT *> graphMap; InitGraphics(); SetWindowTitle("Pathfinder"); string backgroundFile; bool timeToQuit = false; cout << "This masterful piece of work is a graph extravaganza!" << endl; while (true) { cout << "Your options are:" << endl; cout << "(1) Choose a new graph data file" << endl; cout << "(2) Find shortest path using Dijkstra's algorithm" << endl; cout << "(3) Compute the minimal spanning tree using Kruskal's algorithm" << endl; cout << "(4) Determine if the graph has cycles" << endl; cout << "(5) Quit" << endl; cout << "Enter choice: "; int choice = GetInteger(); string datafile; void UpdateDisplay(); switch (choice) { case 1: cout << "Enter the name of the data file: "; datafile = GetLine(); //datafile = "Small.txt"; //datafile = "USA.txt"; //datafile = "Stanford.txt"; graph.clear(); graphMap.clear(); backgroundFile = ReadGraph(graph, graphMap, datafile); break; case 2: if (backgroundFile == "") { cout << "No file is specified" << endl; } else { UpdateDisplay(); MovePen(0,0); DrawNamedPicture(backgroundFile); DrawNodesAndArcs(graph); cout << "(2) Finding shortest path using Dijkstra's algorithm" << endl; HandleShortestPath(graph); } break; case 3: if (backgroundFile == "") { cout << "No file is specified" << endl; } else { cout << "(3) Computing the minimal spanning tree using Kruskal's algorithm" << endl; UpdateDisplay(); MovePen(0,0); DrawNamedPicture(backgroundFile); //DrawNodesAndArcs(graph); minimumSpanningTree(graph, graphMap); } break; case 4: if (backgroundFile == "") { cout << "No file is specified" << endl; } else { graphT graph2; graph2.allNodes = graph; cout << "(4) Determining if the graph has cycles" << endl; if (IsCyclicGraph(graph2)) cout << "Yes, it is cyclic" << endl; else cout << "No, it is not cyclic" << endl; } break; case 5: cout << "Thanks for using Pathfinder. Bye!" << endl; timeToQuit = true; break; default: cout << "Invalid choice" << endl; break; } if (timeToQuit) break; } return (0); }
int main(int argc,char *argv[]) { printf("Setting up signals \n"); signal(SIGINT, sig_handler); signal(SIGTERM, sig_handler); int *g; int *new_g; int gsize; int count; int i; int j; int best_count; int best_i; int best_j; void *taboo_list; int val,iter,jter; int gt[2]; int t=INITEM; int sock = -1; char Fname[255]; char c; int ilim = 8; while((c = getopt(argc,argv,ARGS)) != EOF) { switch(c) { case 'f': strncpy(Fname,optarg,sizeof(Fname)); break; case 'l': printf("optarg: %s", optarg); ilim = atoi(optarg); break; default: fprintf(stderr, "test_clique_count unrecognized argument: %c\n",c); fflush(stderr); break; } } if(!ReadGraph(Fname,&g,&gsize)) { gsize = ilim; g = PaleyGraph(ilim); } /* * make a fifo to use as the taboo list */ taboo_list = FIFOInitEdge(TABOOSIZE); if(taboo_list == NULL) { exit(1); } int best_clique = INITEM; int flag = 0; int min_count = BIGCOUNT; //int term = atoi(argv[1]); /* * while we do not have a publishable result */ while(gsize <= ilim) { printf("Graph size is %d\n", gsize); /* * find out how we are doing */ count = CliqueCount(g,gsize); int * cliques = (int*)malloc( (gsize)* (gsize) *sizeof(int)); memset (cliques,INICLI,(gsize)* (gsize)); /* * if we have a counter example */ if(count == 0) { printf("Eureka! Counter-example found!\n"); min_count = BIGCOUNT; FILE *fp; //printf("Filename: %s", buf); fp = fopen("result.state", "w"); PrintGraphToFile(g, gsize, fp); fclose(fp); //socket_upload_2(sock, -1, -1, count, gsize, g); /* * make a new graph one size bigger */ new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int)); if(new_g == NULL) exit(1); /* * copy the old graph into the new graph leaving the * last row and last column alone */ CopyGraph(g,gsize,new_g,gsize+1); /* * zero out the last column and last row */ for(i=0; i < (gsize+1); i++) { if(drand48() > 0.5) { new_g[i*(gsize+1) + gsize] = 0; // last column new_g[gsize*(gsize+1) + i] = 0; // last row } else { new_g[i*(gsize+1) + gsize] = 1; // last column new_g[gsize*(gsize+1) + i] = 1; // last row } } /* * throw away the old graph and make new one the * graph */ free(g); g = new_g; gsize = gsize+1; /* * reset the taboo list for the new graph */ taboo_list = FIFOResetEdge(taboo_list); /* * keep going */ continue; } /* * otherwise, we need to consider flipping an edge * * let's speculative flip each edge, record the new count, * and unflip the edge. We'll then remember the best flip and * keep it next time around * * only need to work with upper triangle of matrix => * notice the indices */ best_clique = INICLI; time_t tim; srand((unsigned) time(&tim)); // Introducing randomization into system int choice = rand() % 10; printf("choice: %d \n", choice); if (choice == 0){ i=rand()%gsize; j=rand()%gsize; while (FIFOFindEdge(taboo_list,i,j)){ i=rand()%gsize; j=rand()%gsize; } gt[0]=i; gt[1]=j; g[gt[0]*gsize+gt[1]] = 1 - g[gt[0]*gsize+gt[1]]; // Getting clique count of edges on flipping - assuming random move is best best_clique=CliqueCount_D(g,gsize,gt[0],gt[1], 0); g[gt[0]*gsize+gt[1]] = 1 - g[gt[0]*gsize+gt[1]]; } else{ for(i=0; i < gsize; i++) { for(j=i+1; j < gsize; j++) { if(!FIFOFindEdge(taboo_list,i,j)){ // Clique Count without flip int old_clique = CliqueCount_D(g,gsize,i,j, 0); // Clique Count with flip int new_clique = CliqueCount_D(g,gsize,i,j, 1); // Improvement with flip cliques[i*gsize+j] = count + new_clique - old_clique; } } } // Finding edges in clique for(i=0; i < gsize; i++) { for(j=i+1; j < gsize; j++) { if(!FIFOFindEdge(taboo_list,i,j) ) { if(cliques[i*gsize+j] < best_clique ) { best_clique = cliques[i*gsize+j]; gt[0] = i; gt[1] = j; } } } } } printf("2\n"); if(min_count > count) { min_count = count; } if (best_clique <= count){ g[gt[0]*gsize+gt[1]] = 1 - g[gt[0]*gsize+gt[1]]; if( CliqueCount(g, gsize) > count) { g[gt[0]*gsize+gt[1]] = 1 - g[gt[0]*gsize+gt[1]]; } } printf("3\n"); FIFOInsertEdge(taboo_list,gt[0],gt[1]); printf("4\n"); t-=DTEM; if (t==0){ t=INITEM; } printf("5\n"); //socket_upload_2(sock, gt[0], gt[1], count, gsize, g); printf("size: %d, temperature: %d, count: %d, best_clique: %d\n", gsize, t, count, best_clique); free(cliques); g_latest = g; g_size_latest = gsize; g_count_latest = count; } FIFODeleteGraph(taboo_list); return(0); }
sparse_matrix* graph_partition(LIST *list , partition_t* partition_info) { graph_t* graph; params_t *params; idx_t options[METIS_NOPTIONS], status; idx_t objval; sparse_matrix* matrix = (sparse_matrix*)malloc(sizeof(sparse_matrix)); graph = ReadGraph(list); params = bmalloc(sizeof(*params), "Allocating memory for params"); METIS_SetDefaultOptions(options); METIS_init_params(params, graph->ncon); options[METIS_OPTION_OBJTYPE] = params->objtype; options[METIS_OPTION_CTYPE] = params->ctype; options[METIS_OPTION_IPTYPE] = params->iptype; options[METIS_OPTION_RTYPE] = params->rtype; options[METIS_OPTION_NO2HOP] = params->no2hop; options[METIS_OPTION_MINCONN] = params->minconn; options[METIS_OPTION_CONTIG] = params->contig; options[METIS_OPTION_SEED] = params->seed; options[METIS_OPTION_NITER] = params->niter; options[METIS_OPTION_NCUTS] = params->ncuts; options[METIS_OPTION_UFACTOR] = params->ufactor; options[METIS_OPTION_DBGLVL] = params->dbglvl; //print_input_data(graph,params); params->tpwgts = NULL; params->ubvec = NULL; partition_info->partion_table = imalloc(graph->nvtxs, "Allocate memory for part"); switch (params->ptype) { case METIS_PTYPE_RB: status = METIS_PartGraphRecursive(&graph->nvtxs, &graph->ncon, graph->xadj, graph->adjncy, graph->vwgt, graph->vsize, graph->adjwgt, ¶ms->nparts, params->tpwgts, params->ubvec, options, &objval, partition_info->partion_table); break; case METIS_PTYPE_KWAY: status = METIS_PartGraphKway(&graph->nvtxs, &graph->ncon, graph->xadj, graph->adjncy, graph->vwgt, graph->vsize, graph->adjwgt, ¶ms->nparts, params->tpwgts, params->ubvec, options, &objval, partition_info->partion_table); break; } if (status != METIS_OK) { fprintf(stderr,"\n***Metis returned with an error.***\n"); return NULL; } partition_info->size = graph->nvtxs; partition_info->noOfParts = params->nparts; WritePartition(params->filename, partition_info->partion_table, graph->nvtxs, params->nparts); printf("Objval: %d\n",objval); matrix->nz = -1; matrix->n = graph->nvtxs; matrix->p = graph->xadj; matrix->i = graph->adjncy; matrix->x = NULL; return matrix; }
int main(int argc, char **argv) { Parameters *parameters; ULONG numLabels; Graph *g1; Graph *g2; Graph *g2compressed; InstanceList *instanceList; ULONG numInstances; ULONG subSize, graphSize, compressedSize; double subDL, graphDL, compressedDL; double value; Label label; parameters = GetParameters(argc, argv); g1 = ReadGraph(argv[argc - 2], parameters->labelList, parameters->directed); g2 = ReadGraph(argv[argc - 1], parameters->labelList, parameters->directed); instanceList = FindInstances(g1, g2, parameters); numInstances = CountInstances(instanceList); printf("Found %lu instances.\n\n", numInstances); g2compressed = CompressGraph(g2, instanceList, parameters); // Compute and print compression-based measures subSize = GraphSize(g1); graphSize = GraphSize(g2); compressedSize = GraphSize(g2compressed); value = ((double) graphSize) / (((double) subSize) + ((double) compressedSize)); printf("Size of graph = %lu\n", graphSize); printf("Size of substructure = %lu\n", subSize); printf("Size of compressed graph = %lu\n", compressedSize); printf("Value = %f\n\n", value); // Compute and print MDL based measures numLabels = parameters->labelList->numLabels; subDL = MDL(g1, numLabels, parameters); graphDL = MDL(g2, numLabels, parameters); numLabels++; // add one for new "SUB" vertex label if ((parameters->allowInstanceOverlap) && (InstancesOverlap(instanceList))) numLabels++; // add one for new "OVERLAP" edge label compressedDL = MDL(g2compressed, numLabels, parameters); // add extra bits to describe where external edges connect to instances compressedDL += ExternalEdgeBits(g2compressed, g1, numInstances); value = graphDL / (subDL + compressedDL); printf("DL of graph = %f\n", graphDL); printf("DL of substructure = %f\n", subDL); printf("DL of compressed graph = %f\n", compressedDL); printf("Value = %f\n\n", value); if (parameters->outputToFile) { // first, actually add "SUB" and "OVERLAP" labels label.labelType = STRING_LABEL; label.labelValue.stringLabel = SUB_LABEL_STRING; StoreLabel(& label, parameters->labelList); label.labelValue.stringLabel = OVERLAP_LABEL_STRING; StoreLabel(& label, parameters->labelList); parameters->posGraph = g2compressed; WriteGraphToDotFile(parameters->outFileName, parameters); printf("Compressed graph written to dot file %s\n", parameters->outFileName); } FreeGraph(g2compressed); FreeInstanceList(instanceList); FreeGraph(g1); FreeGraph(g2); FreeParameters(parameters); return 0; }
/* search flip new edge first if stuck flip all */ void tabu_search(){ int *g; int *new_g; int gsize; int count; int i; int j; int best_count; int best_i; int best_j; /* some vars for storing result of flip_2_edge */ int best_count_2; int node[4]; /* start with a graph of size 8 */ if( !ReadGraph("204.ce", &g, &gsize) ){ fprintf(stderr, "cannot read\n" ); fflush(stderr); exit(1); } bool flip_new_edge_only = true; int tabu_size; int stuck_num; int stuck_cnt; int stuck_threshold = 10; /* tabu list */ std::set<int> ban_s; std::queue<int> ban_q; /* best_count's collector */ std::vector<int> best_K; int best_start = 0; /* search */ int ra1; int ra2; while(gsize < MAXSIZE){ count = CliqueCount( g, gsize, flip_new_edge_only ); best_K.clear(); best_start = 0; if( count == 0 ){ printf("...Euraka! Counter example FOUND!\n"); PrintGraph(g, gsize); new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int)); if(new_g == NULL) exit(1); CopyGraph( g, gsize, new_g, gsize + 1 ); for(i=0; i<gsize+1; i++){ ra1 = rand() % 2; if(ra1 == 0){ new_g[i*(gsize+1) + gsize] = 0; new_g[gsize*(gsize+1) + i] = 0; } else{ new_g[i*(gsize+1) + gsize] = 1; new_g[gsize*(gsize+1) + i] = 1; } } free(g); g = new_g; gsize++; ban_s.clear(); clearQ(ban_q); flip_new_edge_only = true; stuck_num = 0; stuck_cnt = 0; continue; } best_count = BIGCOUNT; int key; size_t sz; best_count_2 = BIGCOUNT; if( flip_new_edge_only ){ j = gsize - 1; for(i=0; i<gsize-1; i++){ flip_1_edge(g, gsize, i, j, ban_s, best_K, best_start, best_count, true); } } else{ /* flip 1 edge */ for(i=0; i<gsize; i++){ for(j=i+1; j<gsize; j++){ ra1 = rand() % 30; if(ra1 == 0){ flip_1_edge(g, gsize, i, j, ban_s, best_K, best_start, best_count, false); } } } } if(best_count == BIGCOUNT){ printf("no best found, terminating..\n"); exit(1); } sz = best_K.size(); if(best_start < sz - 1){ try_flip_2_edge(g, gsize, best_count_2, best_K, best_start, node, flip_new_edge_only); } tabu_size = (flip_new_edge_only)? gsize/4 : gsize + gsize; if(best_count <= best_count_2){ /* flip 1 edge */ ra1 = (best_start == sz - 1)? best_start : best_start + rand() % (sz - best_start); key = best_K[ra1]; best_i = getI(key); best_j = getJ(key); g[ best_i*gsize + best_j ] = 1 - g[ best_i*gsize + best_j ]; put_to_tabu_list(ban_q, ban_s, tabu_size, key); /* stuck? */ if( flip_new_edge_only ){ i = stuck_num - best_count; if( i < 0 ) i = -i; if( i < 3 ){ stuck_cnt++; if(stuck_cnt == stuck_threshold){ printf("stucked..\n.\n"); flip_new_edge_only = false; stuck_cnt = 0; stuck_num = 0; } } else{ stuck_num = best_count; stuck_cnt = 0; } } printf("ce size: %d, best_count: %d, best edge: (%d, %d), new color: %d\n", gsize, best_count, best_i, best_j, g[best_i*gsize + best_j]); } else{ /* flip 2 edge */ g[ node[0]*gsize + node[1] ] = 1 - g[ node[0]*gsize + node[1] ]; g[ node[2]*gsize + node[3] ] = 1 - g[ node[2]*gsize + node[3] ]; put_to_tabu_list(ban_q, ban_s, tabu_size, getKey(node[0], node[1])); put_to_tabu_list(ban_q, ban_s, tabu_size, getKey(node[0], node[1])); printf("ce size: %d, best_count: %d, best edge: (%d, %d), (%d, %d)\n", gsize, best_count_2, node[0], node[1], node[2], node[3]); } /* rinse and repeat */ } }
int main(int argc,char *argv[]) { int *g; int *new_g; int gsize; int count; int i; int j; int best_count; int best_i; int best_j; int best_k; void *taboo_list; int val,iter,jter; char fname[255]; FILE *fp; char bc[255]; int fd; /* * start with graph of size 8 */ if (argc < 2) { gsize = 8; g = (int *)malloc(gsize*gsize*sizeof(int)); if(g == NULL) { exit(1); } /* * start out with all zeros */ memset(g,0,gsize*gsize*sizeof(int)); val = 0, iter = 0, jter=0; for( iter=0; iter<gsize; iter++){ for( jter = 0; jter< gsize; jter++){ g[iter*gsize + jter] = val; val = 1 - val; } } // PrintGraph(g, gsize); } else if (argc == 2) { gsize = atoi(argv[1]); g = (int *)malloc(gsize*gsize*sizeof(int)); if(g == NULL) { exit(1); } g = PaleyGraph(gsize); } else { char graphfile[256]; strcpy(graphfile, argv[2]); gsize = atoi(argv[1]); //printf("gsize=%d", gsize); g = (int *)malloc(gsize*gsize*sizeof(int)); ReadGraph(graphfile, &g, &gsize); printf("\nStarting from given graph of size %d\n.", gsize); fflush(stdout); } /* *make a fifo to use as the taboo list */ taboo_list = FIFOInitEdge(TABOOSIZE); if(taboo_list == NULL) { exit(1); } /* * while we do not have a publishable result */ while(gsize < 206) { /* * find out how we are doing */ count = CliqueCount(g,gsize); /* * if we have a counter example */ if(count == 0) { // printf("Eureka! i Counter-example found!\n"); sprintf(fname,"solutions/CE-%d.txt",gsize); fp = fopen(fname,"w"); char *key; (void)MakeGraphKey(g,gsize,&key); PrintGraph(g,gsize,fp, key); fclose(fp); /* if(gsize == 31) { FILE *fp; char buf[100]; bzero(buf, 100); sprintf(buf, "graph_%d.state", gsize); printf("Filename: %s", buf); fp = fopen(buf, "w+"); PrintGraphToFile(g, gsize, fp); fclose(fp); } */ free(key); /* * make a new graph one size bigger */ new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int)); if(new_g == NULL) exit(1); /* * copy the old graph into the new graph leaving the * last row and last column alone */ CopyGraph(g,gsize,new_g,gsize+1); /* * zero out the last column and last row */ for(i=0; i < (gsize+1); i++) { if(drand48() > 0.5) { new_g[i*(gsize+1) + gsize] = 0; // last column new_g[gsize*(gsize+1) + i] = 0; // last row } else { new_g[i*(gsize+1) + gsize] = 1; // last column new_g[gsize*(gsize+1) + i] = 1; // last row } } /* * throw away the old graph and make new one the * graph */ free(g); g = new_g; gsize = gsize+1; /* * reset the taboo list for the new graph */ taboo_list = FIFOResetEdge(taboo_list); /* * keep going */ continue; } /* * otherwise, we need to consider flipping an edge * * let's speculative flip each edge, record the new count, * and unflip the edge. We'll then remember the best flip and * keep it next time around * * only need to work with upper triangle of matrix => * notice the indices */ best_count = BIGCOUNT; for(i=0; i < gsize; i++) { for(j=i+1; j < gsize; j++) { /* * flip two edges (i,j), (i,random(j) + 1) */ int k = getRandomJ(gsize); g[i*gsize+j] = 1 - g[i*gsize+j]; if (k == j) k = j + 1; g[i*gsize + k] = 1 - g[i*gsize + k]; count = CliqueCount(g,gsize); /* * is it better and the i,j,count not taboo? */ if((count < best_count) && // !FIFOFindEdge(taboo_list,i,j)) !FIFOFindEdgeCount(taboo_list,i,j,count) && !FIFOFindEdgeCount(taboo_list,i,k, count)) { /* no need to store j + 1 */ best_count = count; best_i = i; best_j = j; best_k = k; } /* * flip it back */ g[i*gsize+j] = 1 - g[i*gsize+j]; g[i*gsize+k] = 1 - g[i*gsize+k]; } } if(best_count == BIGCOUNT) { printf("no best edge found, terminating\n"); exit(1); } /* * keep the best flip we saw */ g[best_i*gsize+best_j] = 1 - g[best_i*gsize+best_j]; g[best_i*gsize + best_k] = 1 - g[best_i*gsize + best_k]; /* * taboo this graph configuration so that we don't visit * it again */ count = CliqueCount(g,gsize); // FIFOInsertEdge(taboo_list,best_i,best_j); FIFOInsertEdgeCount(taboo_list,best_i,best_j,count); FIFOInsertEdgeCount(taboo_list,best_i,best_k,count); /* printf("ce size: %d, best_count: %d, best edges: (%d,%d) (%d,%d), new colors: %d %d\n", gsize, best_count, best_i, best_j, best_i, best_k, g[best_i*gsize+best_j], g[best_i*gsize+best_k]); */ /* write update to file */ sprintf(fname,"solutions/CE-%d-upd.txt",gsize); sprintf(bc,"%d",best_count); fp = fopen(fname, "w+"); if (fp == NULL) { printf("\n Ah file error ? \n"); exit(0); } fd = fileno(fp); ftruncate(fd, 0); PrintGraph(g,gsize,fp, bc); fclose(fp); /* * rinse and repeat */ } FIFODeleteGraph(taboo_list); return(0); }