int main(int argc, char **argv) { char *inputFilename; char *outputFilename; if (!parseCmdLineSimple(argc, argv, "ss", &inputFilename, &outputFilename)) { printf("Usage: mtx2gr input output\n"); exit(1); } int nVertices; std::vector<int> srcs; std::vector<int> dsts; std::vector<int> edgeValues; loadGraph(inputFilename, nVertices, srcs, dsts, &edgeValues); printf("Read input file with %d vertices and %zd edges\n", nVertices, dsts.size()); printf("Converting to CSR\n"); std::vector<int> offsets(nVertices + 1); std::vector<int> csrDsts(dsts.size()); std::vector<int> sortIndices(dsts.size()); std::vector<int> sortedEdgeValues(dsts.size()); edgeListToCSR<int>(nVertices, dsts.size(), &srcs[0], &dsts[0] , &offsets[0], &csrDsts[0], &sortIndices[0]); for (size_t i = 0; i < sortIndices.size(); ++i) sortedEdgeValues[i] = edgeValues[sortIndices[i]]; printf("writing output\n"); writeGraph_binaryCSR(outputFilename, nVertices, dsts.size() , &offsets[0], &csrDsts[0], &sortedEdgeValues[0]); }
int MainWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QMainWindow::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { switch (_id) { case 0: loadGraph(); break; case 1: saveGraph(); break; case 2: saveGraphVrml(); break; case 3: setDrawGraph((*reinterpret_cast< bool(*)>(_a[1]))); break; case 4: setDrawHirarchy((*reinterpret_cast< bool(*)>(_a[1]))); break; default: ; } _id -= 5; } return _id; }
void testProgram() { FILE *file1 = fopen("input.in", "r"); FILE *file2 = fopen("output.data", "w"); graph *G = loadGraph(file1); int **testcost = alocateMemoryForCost(G->noOfVertices); int *testpredecesors = allocateMemoryForPredecesors(G->noOfVertices); BellmanFord(G, 0, testcost, testpredecesors); for (int i = 0; i < G->noOfVertices; i++) { fprintf_s(file2, "%d\n", testcost[1][i]); } fclose(file1); fclose(file2); file1 = fopen("output.data", "r"); file2 = fopen("result.txt", "r"); if (compareFiles(file1, file2)) { printf_s("Test succeded!\n"); } else { printf_s("Test failed!\n"); } }
int main(){ //-----------------------------------------Loading and Printing the Graph------------------------------ graph *G; FILE* f; f = fopen("cost.txt", "r"); G = loadGraph(f); printf("\n Edges and Costs: \n"); for(int i = 0; i < G->noOfEdges; i++){ printf("[%d <-> %d] --- cost = %d \n", G->pEdge[i].source , G->pEdge[i].destination, G->pEdge[i].weight); } //------------------------------------------------END--------------------------------------------------- //-----------------------------------------------PRIM--------------------------------------------------- int V[50][50], Q[50], H[50], n = 0, r = 0, k=0; //----| Data for Prim's Alg // ce reprezinta??? k = prim(V, Q, H, n, r, G); printf("\n Prim: \n"); displayMST(H, n); printf("\n MST cost = %d \n", k); //-----------------------------------------------END------------------------------------------------------ //---------------------------------------------Kruskall--------------------------------------------------- int p, m, L[20]; //----| Data for Kruskall's Alg krusk(n, m, L, G); //-----------------------------------------------END----------------------------------------------------- system("pause"); }
ClusterEvaluator::ClusterEvaluator(Graph* g, hmap_uint_suint* cls, hmap_uint_suint* nc, std::vector<std::string>* clbs, uint vnn) { loadGraph(g); loadClusters(cls, nc); cluster_labels = clbs; v_num_nodes = vnn; }
Graph* init() { Graph* g = newGraph(0); loadGraph(g, "mst.txt"); parent = (int*) malloc((g->nvertices+1) * sizeof(int)); int i; for (i = 0; i <= g->nvertices; i++) { parent[i] = -1; } return g; }
void driverProgram(char *inputFile, char *outputFile) { FILE *fin = fopen(inputFile, "r"); FILE *fout = fopen(outputFile, "w"); int source; graph *G = loadGraph(fin); int **cost = alocateMemoryForCost(G->noOfVertices); int *predecesors = allocateMemoryForPredecesors(G->noOfVertices); printf_s("Give the source vertex:"); scanf_s("%d", &source); BellmanFord(G, source, cost, predecesors); for (int i = 0; i < G->noOfVertices; i++) { fprintf_s(fout, "%d\n", cost[1][i]); } while (true) { int destination; printf_s("Give the vertex to which you want to reconstruct the path:"); scanf_s("%d", &destination); if (cost[1][destination] == infinite) { printf_s("there is no path to %d from %d\n", destination, source); } else if (cost[1][destination] == minfinite) { printf_s("it is a negative cycle cannot display path\n"); } else { reconstructPath(source, destination, G, predecesors); } printf_s("Continue? \n1.Yes\n0.No\n"); int dummy; scanf_s("%d",&dummy); if (dummy == 0) { break; } } fclose(fin); fclose(fout); }
void QGraphWidget::open() { QSettings settings("LITIS", "GEM++gui"); QString root; #if defined(LINUX) root = "/home"; #elif defined(WIN32) root = "C:\\"; #endif QString graphPath = settings.value(QString("%1_graph_path").arg(typeNames[type_]), root).toString(); QString fileName = QFileDialog::getOpenFileName(this, "Open a graph file", graphPath, "Graph *.gml/*.gxl (*.gml *.gxl)"); if(!fileName.isEmpty()) { loadGraph(fileName); settings.setValue(QString("%1_graph_path").arg(typeNames[type_]), QFileInfo(fileName).path()); } }
LoadGraphWindow::LoadGraphWindow( QWidget* parent ) { setModal( true ); resize( 600,250 ); setWindowTitle( tr( "Load graph from database" ) ); loadButton = createButton( tr( "Load" ), SLOT( loadGraph() ) ); removeButton = createButton( tr( "Remove" ), SLOT( removeGraph() ) ); renameButton = createButton( tr( "Rename" ), SLOT( renameGraph() ) ); QPushButton* cancelButton = new QPushButton( tr( "Cancel" ) ); cancelButton->setFocusPolicy( Qt::NoFocus ); connect( cancelButton, SIGNAL( clicked() ), this, SLOT( close() ) ); numberOfGraphs = new QLabel; graphList << tr( "ID" ) << tr( "Name" ) << tr( "No. of layouts" ) << tr( "No. of nodes" ) << tr( "No. of edges" ); graphsTable = new QTableWidget( this ); graphsTable->setSelectionBehavior( QAbstractItemView::SelectRows ); graphsTable->setRowCount( 0 ); graphsTable->setColumnCount( 5 ); graphsTable->setHorizontalHeaderLabels( graphList ); graphsTable->horizontalHeader()->setResizeMode( 0, QHeaderView::Interactive ); graphsTable->horizontalHeader()->setResizeMode( 1, QHeaderView::Stretch ); graphsTable->horizontalHeader()->setResizeMode( 2, QHeaderView::ResizeToContents ); graphsTable->horizontalHeader()->setResizeMode( 3, QHeaderView::ResizeToContents ); graphsTable->horizontalHeader()->setResizeMode( 4, QHeaderView::ResizeToContents ); graphsTable->verticalHeader()->hide(); graphsTable->setShowGrid( true ); createGraphTable(); QHBoxLayout* buttonsLayout = new QHBoxLayout; buttonsLayout->addStretch(); buttonsLayout->addWidget( loadButton ); buttonsLayout->addWidget( renameButton ); buttonsLayout->addWidget( removeButton ); buttonsLayout->addWidget( cancelButton ); QGridLayout* mainLayout = new QGridLayout; mainLayout->addWidget( graphsTable, 3, 0, 1, 3 ); mainLayout->addWidget( numberOfGraphs, 4, 0, 1, 3 ); mainLayout->addLayout( buttonsLayout, 5, 0, 1, 3 ); setLayout( mainLayout ); }
int main(int argc, char* argv[]) { Graph* g = newGraph(0); loadGraph(g, "graph.txt"); int* result = (int*) malloc(g->nvertices * sizeof(int)); bandwidth(g,result); printf("Bandwidth: "); int i; for(i=0; i<g->nvertices; i++) { printf("%d ", result[i]); } printf("\n"); deleteGraph(g); return 0; }
bool processMenu(int choice) { string name; switch(choice-1) { case CREATE_NODE: createNode(); break; case DELETE_NODE: deleteNode(); break; case CREATE_RELATION: createRelation(); break; case DELETE_RELATION: deleteRelation(); break; case SAVE_GRAPH: saveGraph(); break; case LOAD_GRAPH: loadGraph(); break; case DISPLAY_GRAPH: displayGraph(); break; case RUN_PRIM: runPrim(); break; case QUIT: return true; break; default: cout << "Invalid input" << endl; cout << endl; break; } return false; }
void run(context_t& ctx, bool directed) { bool is_master = ctx.dc.procid() == 0; timer_start(is_master); #ifdef GRANULA granula::operation powergraphJob("PowerGraph", "Id.Unique", "Job", "Id.Unique"); granula::operation loadGraph("PowerGraph", "Id.Unique", "LoadGraph", "Id.Unique"); if(is_master) { cout<<powergraphJob.getOperationInfo("StartTime", powergraphJob.getEpoch())<<endl; cout<<loadGraph.getOperationInfo("StartTime", loadGraph.getEpoch())<<endl; } #endif // process parmaeters global_directed = directed; // load graph timer_next("load graph"); graph_type graph(ctx.dc); load_graph(graph, ctx); graph.finalize(); #ifdef GRANULA if(is_master) { cout<<loadGraph.getOperationInfo("EndTime", loadGraph.getEpoch())<<endl; } #endif // start engine timer_next("initialize engine"); graphlab::omni_engine<triangle_count> engine(ctx.dc, graph, "synchronous", ctx.clopts); engine.signal_all(); #ifdef GRANULA granula::operation processGraph("PowerGraph", "Id.Unique", "ProcessGraph", "Id.Unique"); if(is_master) { cout<<processGraph.getOperationInfo("StartTime", processGraph.getEpoch())<<endl; } #endif // run algorithm timer_next("run algorithm"); engine.start(); #ifdef GRANULA if(is_master) { cout<<processGraph.getOperationInfo("EndTime", processGraph.getEpoch())<<endl; } #endif #ifdef GRANULA granula::operation offloadGraph("PowerGraph", "Id.Unique", "OffloadGraph", "Id.Unique"); if(is_master) { cout<<offloadGraph.getOperationInfo("StartTime", offloadGraph.getEpoch())<<endl; } #endif // print output if (ctx.output_enabled) { timer_next("print output"); vector<pair<graphlab::vertex_id_type, vertex_data_type> > data; collect_vertex_data(graph, data, is_master); for (size_t i = 0; i < data.size(); i++) { (*ctx.output_stream) << data[i].first << " " << data[i].second.clustering_coef << endl; } } timer_end(); #ifdef GRANULA if(is_master) { cout<<offloadGraph.getOperationInfo("EndTime", offloadGraph.getEpoch())<<endl; cout<<powergraphJob.getOperationInfo("EndTime", powergraphJob.getEpoch())<<endl; } #endif }
int main(int argc, char **argv) { double B_max = 10, w = 0.5, b = 5, p_star = 0.05, p = 0.7, theta = 0.3, a = 0.001, z = 0, use2Opt = 1, use2OptE = 1, repeat = 1, z_max = 1000; struct tag { char *tag; double *var; } tags[] = { {"B_max", &B_max}, {"w", &w}, {"b", &b}, {"p_star", &p_star}, {"p", &p}, {"theta", &theta}, {"a", &a}, {"z", &z}, {"use2Opt", &use2Opt}, {"use2OptE", &use2OptE}, {"repeat", &repeat}, {"z_max", &z_max}, {NULL, NULL} }; if (argc != 3) { fprintf(stderr, "SYNTAX: %s <filename of graph> <filename of control file>\n", argv[0]); exit(1); } if (loadGraph(argv[1])) printf("File %s not found.\n", argv[1]); header(); FILE *f = fopen(argv[2], "r"); if (f == NULL) { printf("Cannot open file %s.\n", argv[2]); exit(1); } char buffer[256]; while (fgets(buffer, 255, f)) { char this_tag[256], this_experiment[256]; char *bp = buffer; while ((*bp != 0) && isspace(*bp)) bp++; if (*bp == 0) continue; if (strncmp(buffer, "run", 3) == 0) { sscanf(buffer, "%s %s", this_tag, this_experiment); for (int run = 0; run < repeat; run++) { fprintf(stderr, "Run %s (%d / %.0lf)\n", this_experiment, run, repeat); initialize(); double time_used = 0; for (int z = 1; z <= z_max; z++) { double start_time = get_utime(); iteration(B_max, w, b, p_star, p, theta, a, (int) z, (int) use2Opt, (int) use2OptE); time_used += get_utime() - start_time; output((int) use2Opt, (int) use2OptE, w, p_star, p, theta, a, b, (int) B_max, run, z, time_used, this_experiment); } } } else { char this_tag[256]; double this_value; sscanf(buffer, "%s %lf", this_tag, &this_value); struct tag *t; for (t = tags; t->tag; t++) { if (strcmp(this_tag, t->tag) == 0) { *t->var = this_value; break; } } if (!t->tag) { fprintf(stderr, "Unrecognized tag %s in control file.\n", this_tag); exit(1); } } } return 0; }
int main() { FILE* fin = NULL; char c, fileName[20]; int i; do { printf ("\n <<<<<<<<<<<<<<<<<<<<<< MENU >>>>>>>>>>>>>>>>>>>>>>\n\n"); printf ("\n 1. Generate a new test file AND display it;"); printf ("\n 2. Generate a new test file WITHOUT displaying it;\n"); printf ("\n 3. Load an existing test file AND display it;"); printf ("\n 4. Load an existing test file WITHOUT displaying it;\n"); printf ("\n 5. Exit the program.\n"); printf ("\n Choose an option ('c' to clear screen): "); scanf (" %c", &c); if (c == 'c') { for (i = 0; i < 100; i++) { printf ("\n"); } } else if (c == '1') { printf ("\nGenerate a new test file and display it. Input its name:\n"); scanf ("%s", fileName); graphGenerator (fileName); displayGraph (fin, fileName); } else if (c == '2') { printf ("\nGenerate a new test file. Input its name:\n"); scanf ("%s", fileName); graphGenerator (fileName); } else if (c == '3') { printf ("\nLoad an existing test file and display it. Input its name:\n"); scanf ("%s", fileName); displayGraph (fin, fileName); } else if (c == '4') { printf ("\nLoad an existing test file. Input its name:\n"); scanf ("%s", fileName); } else if (c == '5') { exit(1); } else { printf ("\nThe key you pressed is not a valid option. Please press 1, 2, 3, 4 or 5.\n\n"); } if (c == '1' || c == '2' || c == '3' || c == '4') { fin = fopen (fileName, "r"); if (fin == NULL) { perror ("\n\tError opening file\n"); } else { int nodes; double beta; printf ("\nDefine the damping factor (best between 0.8 and 0.9): "); scanf ("%lf", &beta); double **M = loadGraph (fin, nodes); M = createMatrix_M (M, nodes, beta); double **B = createMatrix_B (nodes, beta); M = matrixSum (M, B, nodes); deallocMatrix <double> (B, nodes); // printf("\n Matrix A = M + B \n"); displayMatrix (M, nodes, nodes); // powerIteration (M, nodes, beta); fclose (fin); } } } while (true); return 0; }
int main(int argc, char *argv[]) { string inputFile = "./dissect/as/as20000102.dimacs"; string outputFile = "./graph"; bool display_output = true; bool write_graph_files = true; bool gro_calc = false; bool ncp_calc = false; int core_to_start = -1; //User input for(int i=1;i<argc;i++) { stringstream ss; if(strcmp(argv[i], "-i")==0) inputFile = argv[i+1]; if(strcmp(argv[i], "-o")==0) outputFile = argv[i+1]; if(strcmp(argv[i], "-silent")==0) display_output = false; if(strcmp(argv[i], "-nofile")==0) write_graph_files = false; if(strcmp(argv[i], "-gromov")==0) gro_calc = true; if(strcmp(argv[i], "-ncp")==0) ncp_calc = true; if(strcmp(argv[i], "-core")==0) core_to_start = atoi(argv[i+1]); } ////Default values if(inputFile.length()==0) { cerr<<"You must provide an input file\n"; exit(EXIT_FAILURE); } ////////////////////////////////////////////////////////////// //----------------------------------------------------------- ////////////////////////////////////////////////////////////// Graph G_o = loadGraph(inputFile,"\t",false); Graph G = connected(G_o); vector<int> core; vector<v_size_t> distances; vector<v_size_t> num_paths; v_size_t N_paths,D,n; int max_core = 0; double A_d, A_p; A_d = 0; A_p = 0; D = 0; N_paths = 0; n = num_vertices(G); graph_traits<Graph>::vertex_iterator vi, vie; property_map<Graph, vertex_index_t>::type index = get(vertex_index,G); core = k_core(G); for(int i=0;i<core.size();++i) { if(core[i] > max_core) max_core = core[i]; } if(core_to_start<=0) core_to_start = max_core; for(tie(vi,vie) = vertices(G); vi != vie; ++vi) { Vert v = *vi; //cout<<G[v].core_num<<" "; BFS_source_all(v,G,distances,num_paths); size_t size = distances.size(); for(size_t i=0;i<size;++i) { if(distances[i] > D) D = distances[i]; A_p += num_paths[i] * distances[i]; A_d += distances[i]; N_paths += num_paths[i]; } } A_p /= N_paths; A_d /= (pow(n, 2) - n); cout<<"Max Core: "<<max_core<<" The diameter: "<<D<<" The avg. path: "<<A_p<<" The avg. dist: "<<A_d<<" The size: "<<n<<"\n"; cout.flush(); string periph_diam = outputFile; string collapse_diam = outputFile; string core_diam = outputFile; ofstream file_periph; ofstream file_collapse; ofstream file_core; periph_diam.append("_periph_diam.out"); collapse_diam.append("_collapse_diam.out"); core_diam.append("_core_diam.out"); file_periph.open(periph_diam.c_str()); file_collapse.open(collapse_diam.c_str()); file_core.open(core_diam.c_str()); file_periph<<(max_core+1)<<"\t"<<D<<"\t"<<A_d<<"\t"<<A_p<<"\n"; file_collapse<<(max_core+1)<<"\t"<<D<<"\t"<<A_d<<"\t"<<A_p<<"\n"; file_core<<(max_core+1)<<"\t"<<0<<"\t"<<0<<"\t"<<"\n"; Graph G_core, G_periph, G_collapse; vector<v_size_t> core_list; vector<v_size_t> periph_list; for(int i=1;i<=max_core;i++) periph_list.push_back(i); for(int i=max_core; i>0; --i) { core_list.push_back(i); periph_list.pop_back(); if(i<=core_to_start) { G_core = get_k_shells(core_list,G); G_periph = get_k_shells(periph_list,G); G_collapse = collapse_core(i,G); stringstream ssperiph; ssperiph<<i; string outputPeriph = outputFile; string outputCore = outputFile; string outputCollapse = outputFile; outputPeriph.append("_periph_"); outputCore.append("_core_"); outputCollapse.append("_collapse_"); outputPeriph.append(ssperiph.str()); outputCore.append(ssperiph.str()); outputCollapse.append(ssperiph.str()); outputPeriph.append(".dimacs"); outputCore.append(".dimacs"); outputCollapse.append(".dimacs"); if(write_graph_files) { write_dimacs(G_periph,outputPeriph); write_dimacs(G_core,outputCore); write_dimacs(G_collapse,outputCollapse); } //Need to make something that checks number of connected components, and then runs this on each one. Just because the whole graph is connected doesn't mean the cores have to be. D = 0; v_size_t n_core = num_vertices(G_core); A_p = 0; A_d = 0; N_paths = 0; for(tie(vi,vie) = vertices(G_core); vi != vie; ++vi) { Vert v = *vi; BFS_source_all(v,G_core,distances,num_paths); size_t size = distances.size(); for(size_t j=0;j<size;++j) { if(distances[j] > D) D = distances[j]; A_p += num_paths[j]*distances[j]; A_d += distances[j]; N_paths += num_paths[j]; } } A_p /= N_paths; vector<bool> found(n_core,false); v_size_t current_comp = 0; vector<v_size_t> comp_size; vector<v_size_t> component(n_core); index = get(vertex_index,G_core); for(tie(vi,vie)=vertices(G_core);vi!=vie;++vi) { Vert v = *vi; v_size_t vind = index[v]; v_size_t current_comp_size = 0; if(!found[vind]) { BFS_vertices_found(v,G_core,found,current_comp,component,current_comp_size); comp_size.push_back(current_comp_size); ++current_comp; } } if(display_output) cout<<"\nCore: "<<i<<"\n"; double sum_of_components = 0; if(display_output) cout<<"# of components in core: "<<comp_size.size()<<" Size of core: "<<num_vertices(G_core)<<"\n"; for(size_t j=0;j<comp_size.size();++j) { if(comp_size[j] > (num_vertices(G_core)/10.0) && display_output) cout<<"Component "<<j<<" Size: "<<comp_size[j]<<"\n"; sum_of_components += pow(comp_size[j],2)-comp_size[j]; } A_d /= sum_of_components; if(display_output) cout<<"The diameter: "<<D<<" The avg. path: "<<A_p<<" The avg. dist: "<<A_d<<" The size: "<<n_core<<"\n"; file_core<<(i)<<"\t"<<D<<"\t"<<A_d<<"\t"<<A_p<<"\n"; cout.flush(); ////////////////////////////////////////////// if(gro_calc && n_core>4) { G_core = connected(G_core); //cout<<"Vertices in new core: "<<num_vertices(G_core)<<"\n"; BFS_distance(G_core); vector< vector<double> > delta = calc_gromov(G_core,D); stringstream ss,tt; ss<<i; unsigned long numQuad = 0; for(size_t j=0;j<delta.size();++j) numQuad += delta[j][0]; ofstream outGrom; string outputFileGrom = outputFile; outputFileGrom.append("_gromov_core_"); outputFileGrom.append(ss.str()); outputFileGrom.append(".txt"); outGrom.open(outputFileGrom.c_str()); tt<<i; ofstream outAvg; string outputFileAvg = outputFile; outputFileAvg.append("_avg_distr_core_"); outputFileAvg.append(tt.str()); outputFileAvg.append(".txt"); outAvg.open(outputFileAvg.c_str()); outGrom<<"#Note: Hyperbolicity only calculated on largest component of core\n"; outGrom<<"#Column format: \n"; outGrom<<"#Max Length in Quadruplet\tNumber of Quadruplets\n"; for(size_t j=0;j<delta.size();++j) { outGrom<<"#~\t"<<j+1<<"\t"<<delta[j][0]<<"\n"; } outGrom<<"#Column format: \n"; outGrom<<"#Delta\tPercent of quadruplets for each length\n"; for(size_t j=1;j<delta[0].size();j++) { //size_t size = delta[i].size(); outGrom<<(j-1)/2.0<<"\t"; for(size_t k=0;k<delta.size();k++) { if(delta[k][0]!=0) (delta[k])[j] = (delta[k])[j]/(delta[k])[0]; outGrom<<delta[k][j]<<"\t"; } outGrom<<"\n"; } for(size_t k=0;k<delta.size();k++) { double avg = 0; for(size_t j=1;j<delta[k].size();j++) { avg += delta[k][j]*(j-1)/2.0; } outAvg<<k+1<<"\t"<<avg<<"\n"; } outGrom.close(); outAvg.close(); } //////////////////////////////////////////////////////// v_size_t n_periph = num_vertices(G_periph); found.assign(n_periph,false); current_comp = 0; comp_size.clear(); component.assign(n_periph,0); index = get(vertex_index,G_periph); for(tie(vi,vie)=vertices(G_periph);vi!=vie;++vi) { Vert v = *vi; v_size_t vind = index[v]; v_size_t current_comp_size = 0; if(!found[vind]) { BFS_vertices_found(v,G_periph,found,current_comp,component,current_comp_size); comp_size.push_back(current_comp_size); ++current_comp; } } if(display_output) cout<<"# of components in periphery: "<<comp_size.size()<<" Size of periphery: "<<num_vertices(G_periph)<<"\n"; for(size_t j=0;j<comp_size.size();++j) if(comp_size[j] > (num_vertices(G_periph)/10.0) && display_output) cout<<"Component "<<j<<" Size: "<<comp_size[j]<<"\n"; G_periph = connected(G_periph); n_periph = num_vertices(G_periph); ///////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //ncp ////////////////////////////////////////////////////////////////////// // v_size_t max_community = n_periph/2; // vector<double> ncp_periph = ncp_calc(G_periph,max_community,1,.001,false); // stringstream ssncp; // ssncp<<i; // string outputNcp = outputFile; // ofstream output_file_ncp; // outputNcp.append("_ncp_periph_"); // outputNcp.append(ssncp.str()); // outputNcp.append(".txt"); // output_file_ncp.open(outputNcp.c_str()); // for(v_size_t k=0; k<max_community;++k) // output_file_ncp<<(k+1)<<"\t"<<ncp_periph[k]<<"\n"; // output_file_ncp.close(); // string label = outputFile; // label.append(" ncp plot"); // string title = outputFile; // title.append(" NCP Plot"); // vector<int> int_to_vec; // int_to_vec.push_back(2); // vector<string> string_to_vec; // string_to_vec.push_back(label); // string outputPNG = ""; // outputPNG.append(outputFile); // outputPNG.append("_ncp_periph_"); // outputPNG.append(ssncp.str()); // outputPNG.append("_ncp_plot"); // produce_loglog_plot(outputNcp,outputPNG,outputPNG,int_to_vec,string_to_vec,title,"Community size", "Conductance","",false); // ///////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////// D = 0; A_p = 0; A_d = 0; N_paths = 0; for(tie(vi,vie) = vertices(G_periph); vi != vie; ++vi) { Vert v = *vi; BFS_source_all(v,G_periph,distances,num_paths); size_t size = distances.size(); for(size_t j=0;j<size;++j) { if(distances[j] > D) D = distances[j]; A_p += num_paths[j]*distances[j]; A_d += distances[j]; N_paths += num_paths[j]; } } A_p /= N_paths; A_d /= (pow(n_periph,2)-n_periph); if(gro_calc && n_periph>4) { BFS_distance(G_periph); vector< vector<double> > delta = calc_gromov(G_periph,D); stringstream ss,tt; ss<<i; unsigned long numQuad = 0; for(size_t j=0;j<delta.size();++j) { numQuad += delta[j][0]; } ofstream outGrom; string outputFileGrom = outputFile; outputFileGrom.append("_gromov_periph_"); outputFileGrom.append(ss.str()); outputFileGrom.append(".txt"); outGrom.open(outputFileGrom.c_str()); tt<<i; ofstream outAvg; string outputFileAvg = outputFile; outputFileAvg.append("_avg_distr_periph_"); outputFileAvg.append(tt.str()); outputFileAvg.append(".txt"); outAvg.open(outputFileAvg.c_str()); outGrom<<"#Column format: \n"; outGrom<<"#Max Length in Quadruplet\tNumber of Quadruplets\n"; for(size_t j=0;j<delta.size();++j) { outGrom<<"#~\t"<<j+1<<"\t"<<delta[j][0]<<"\n"; } outGrom<<"#Column format: \n"; outGrom<<"#Delta\tPercent of quadruplets for each length\n"; for(size_t j=1;j<delta[0].size();j++) { //size_t size = delta[i].size(); outGrom<<(j-1)/2.0<<"\t"; for(size_t k=0;k<delta.size();k++) { if(delta[k][0]!=0) (delta[k])[j] = (delta[k])[j]/(delta[k])[0]; outGrom<<delta[k][j]<<"\t"; } outGrom<<"\n"; } for(size_t k=0;k<delta.size();k++) { double avg = 0; for(size_t j=1;j<delta[k].size();j++) { avg += delta[k][j]*(j-1)/2.0; } outAvg<<k+1<<"\t"<<avg<<"\n"; } outGrom.close(); outAvg.close(); } //cout<<"\nCore: "<<i<<"\n"; if(display_output) cout<<"The diameter: "<<D<<" The avg. path: "<<A_p<<" The avg. dist: "<<A_d<<" The size: "<<n_periph<<"\n"; file_periph<<(i)<<"\t"<<D<<"\t"<<A_d<<"\t"<<A_p<<"\n"; cout.flush(); ////////////////////////////////////////////////// ////////////////////////////////////////////////// D = 0; v_size_t n_collapse = num_vertices(G_collapse); A_p = 0; A_d = 0; N_paths = 0; for(tie(vi,vie) = vertices(G_collapse); vi != vie; ++vi) { Vert v = *vi; BFS_source_all(v,G_collapse,distances,num_paths); size_t size = distances.size(); for(size_t j=0;j<size;++j) { if(distances[j] > D) D = distances[j]; A_p += num_paths[j]*distances[j]; A_d += distances[j]; N_paths += num_paths[j]; } } A_p /= N_paths; found.assign(n_collapse,false); current_comp = 0; comp_size.clear(); component.assign(n_collapse,0); index = get(vertex_index,G_collapse); for(tie(vi,vie)=vertices(G_collapse);vi!=vie;++vi) { Vert v = *vi; v_size_t vind = index[v]; v_size_t current_comp_size = 0; if(!found[vind]) { BFS_vertices_found(v,G_collapse,found,current_comp,component,current_comp_size); comp_size.push_back(current_comp_size); ++current_comp; } } sum_of_components = 0; if(display_output) cout<<"# of components in collapse: "<<comp_size.size()<<" Size of collapse: "<<num_vertices(G_collapse)<<"\n"; cout.flush(); for(size_t j=0;j<comp_size.size();++j) { if(comp_size[j] > (num_vertices(G_collapse)/10.0) && display_output) cout<<"Component "<<j<<" Size: "<<comp_size[j]<<"\n"; sum_of_components += pow(comp_size[j],2)-comp_size[j]; } A_d /= sum_of_components; if(display_output) cout<<"The diameter: "<<D<<" The avg. path: "<<A_p<<" The avg. dist: "<<A_d<<" The size: "<<n_collapse<<"\n"; file_collapse<<(i)<<"\t"<<D<<"\t"<<A_d<<"\t"<<A_p<<"\n"; cout.flush(); ////////////////////////////////////////////// if(gro_calc && n_collapse>4) { BFS_distance(G_collapse); vector< vector<double> > delta = calc_gromov(G_collapse,D); stringstream ss,tt; ss<<i; unsigned long numQuad = 0; for(size_t j=0;j<delta.size();j++) numQuad += delta[j][0]; ofstream outGrom; string outputFileGrom = outputFile; outputFileGrom.append("_gromov_collapse_"); outputFileGrom.append(ss.str()); outputFileGrom.append(".txt"); outGrom.open(outputFileGrom.c_str()); tt<<i; ofstream outAvg; string outputFileAvg = outputFile; outputFileAvg.append("_avg_distr_collapse_"); outputFileAvg.append(tt.str()); outputFileAvg.append(".txt"); outAvg.open(outputFileAvg.c_str()); outGrom<<"#Column format: \n"; outGrom<<"#Max Length in Quadruplet\tNumber of Quadruplets\n"; for(size_t j=0;j<delta.size();j++) { outGrom<<"#~\t"<<j+1<<"\t"<<delta[j][0]<<"\n"; } outGrom<<"#Column format: \n"; outGrom<<"#Delta\tPercent of quadruplets for each length\n"; for(size_t j=1;j<delta[0].size();j++) { //size_t size = delta[i].size(); outGrom<<(j-1)/2.0<<"\t"; for(size_t k=0;k<delta.size();k++) { if(delta[k][0]!=0) (delta[k])[j] = (delta[k])[j]/(delta[k])[0]; outGrom<<delta[k][j]<<"\t"; } outGrom<<"\n"; } for(size_t k=0;k<delta.size();k++) { double avg = 0; for(size_t j=1;j<delta[k].size();j++) { avg += delta[k][j]*(j-1)/2.0; } outAvg<<k+1<<"\t"<<avg<<"\n"; } outGrom.close(); outAvg.close(); } } //////////////////////////////////////////////////////// } file_periph.close(); file_collapse.close(); file_core.close(); return(0); }
int main(){ FILE *fp = fopen("graph.in", "r"); FILE *fRand = fopen("graph2.in", "r"); int y, tests ,source, count=0, cnt=0, destination; int distance[N] = {0}, predecesor[N] = {0}; int distanceSimple[N], distanceMinHeap[N], distanceBruteForce[N]; bool ok; clock_t beginSD,endSD,beginDMH, endDMH, beginDBF, endDBF; struct Graph* G = (Graph*) malloc(sizeof(Graph)); struct MinHeap *mh = (MinHeap*) malloc(sizeof(MinHeap)); Init(mh); do{ puts("________________________________\n"); puts("Choose an option: \n"); puts("1. Load the Graph\n2. 2. Print the Graph\n3. Distance between two nodes\n4. Path between two nodes\n5. Dijkstra\n6. Dijkstra with Min Heap\n7. Brute Force Dijkstra\n8. Compare results\n9. Exit"); puts("________________________________\n"); scanf("%d", &y); switch(y){ case 1: G = loadGraph(fp); system("cls"); break; case 2: printGraph(G); system("cls"); break; case 3://Get shortest distance between two nodes puts("Give the source node: "); scanf("%d", &source); printf("Give the destination node: "); scanf("%d", &destination); getDistance(G, source, destination , mh, distance, predecesor); for(int i = 0; i <= G->V; i ++){ predecesor[i] = 0; distance[i] = 0; } system("cls"); break; case 4://Get shortest path between two nodes puts("Give the source node: "); scanf("%d", &source); printf("Give the destination node: "); scanf("%d", &destination); if( !hasNegativeCosts(G)){//preprocessing puts("\nThe Graph is valid for applying Dijkstra."); DijkstraMH(G, source, mh, distance, predecesor); getPath(G, source, destination, mh, distance, predecesor); for(int i = 0; i <= G->V; i ++){ predecesor[i] = 0; distance[i] = 0; } } else puts("\nThe Graph is invalid for applying Dijkstra.\nOne or more of the edges has negative cost."); getch(); system("cls"); break; case 5://Simple Dijkstra puts("Give the source: "); scanf("%d", &source); if( !hasNegativeCosts(G)){//preprocessing puts("\nThe Graph is valid for applying Dijkstra."); Dijkstra(G, source, distance, predecesor); printResult(G, distance, source); for(int i = 0;i <= G->V; i ++){ predecesor[i] = 0; distance[i] = 0; } } else puts("\nThe Graph is invalid for applying Dijkstra.\nOne or more of the edges has negative cost."); getch(); system("cls"); break; case 6://Dijkstra with Min Heap puts("Give the source: "); scanf("%d", &source); if( !hasNegativeCosts(G)){//preprocessing puts("\nThe Graph is valid for applying Dijkstra."); DijkstraMH(G, source, mh, distance, predecesor); printResult(G, distance, source); for(int i = 0;i <= G->V; i ++){ predecesor[i] = 0; distance[i] = 0; } } else puts("\nThe Graph is invalid for applying Dijkstra.\nOne or more of the edges has negative cost."); getch(); system("cls"); break; case 7://brute force Dijkstra puts("Give the source: "); scanf("%d", &source); if( !hasNegativeCosts(G)){//preprocessing puts("\nThe Graph is valid for applying Dijkstra."); bruteForceDijkstra(source, G, mh, 0, 0, 0, count, distance, predecesor); printResult(G, distance, source); } for(int i = 0; i <= G->V; i ++){ predecesor[i] = 0; distance[i] = 0; } getch(); system("cls"); break; case 8://compare results puts("Give the source: "); scanf("%d", &source); assert((beginSD = clock())!=-1); Dijkstra(G, source, distanceSimple, predecesor); endSD = clock(); beginDMH = clock(); DijkstraMH(G, source, mh, distanceMinHeap, predecesor); endDMH = clock(); beginDBF = clock(); bruteForceDijkstra(source, G, mh, 0, 0, 0, count, distanceBruteForce, predecesor); endDBF = clock(); if(compare(G, distanceSimple, distanceMinHeap, distanceBruteForce)){ puts("\nThe three algorithms provided the same results that are:"); printf("\nSimple Dijkstra:\n"); printResult(G, distanceSimple, source); printf("\nDijkstra with Min Heap:\n"); printResult(G, distanceMinHeap, source); printf("\nBrute Force Dijkstra:\n"); printResult(G, distanceBruteForce, source); } getch(); case 9: return 0; } }while(y != 9); return (0); }
/******************************************************************** * Other constructor ********************************************************************/ NamingGame::NamingGame(std::string filename){ loadGraph(filename); }
ClusterEvaluator::ClusterEvaluator(Graph* g) { loadGraph(g); }
int main (int argc, char** argv) { if (argc == 1) { printf("Usage: graph01 input.data\n"); return 0; } /* CREATE ADJACENCY LISTS */ int n = 0, m = 0, result; IntList* adj_list; IntList* transpose_list; adj_list = loadGraph(&n, &m, argc, argv); transpose_list = fix_graph(transposeGraph(adj_list, n), n); int discoverTime1[n], finishTime1[n], finishStk[n], parent1[n], counter = 1, stackspot = n; memset(discoverTime1, 0, n * sizeof(int)); memset(finishTime1, 0, n * sizeof(int)); memset(finishStk, 0, n * sizeof(int)); memset(parent1, -1, n * sizeof(int)); int discoverTime2[n], finishTime2[n], dfstRoot[n], parent2[n]; memset(discoverTime2, 0, n * sizeof(int)); memset(finishTime2, 0, n * sizeof(int)); memset(parent2, -1, n * sizeof(int)); memset(dfstRoot, 0, n * sizeof(int)); for (int i = 1; i <= n; i++) result = dfsTrace1(adj_list, discoverTime1, finishTime1, finishStk, parent1, &counter, i, &stackspot); counter = 1; for (int i = 0; i < n; i++) result = dfsTrace2(transpose_list, discoverTime2, finishTime2, finishStk, parent2, &counter, finishStk[i], dfstRoot, finishStk[i]); result = result; /* ADJACENCY LIST */ printf("\n__Adjacency List__\n"); // print list print_list(adj_list, n, m); // display stack printf("stack: ["); for (int i = 0; i < n; i++) { if (i != 0) printf(", "); printf("%d", finishStk[i]); } printf("]\n\n"); // table printf("vertex |dtime |ftime |parent\n"); printf("-------|------|------|------\n"); for (int i = 0; i < n; i++) printf("%7d|%6d|%6d|%6d\n", i + 1, discoverTime1[i], finishTime1[i], parent1[i]); printf("\n\n"); /* TRANSPOSE LIST */ printf("__Transpose List__\n"); // print transpose list print_list(transpose_list, n, m); printf("\n"); // table printf("vertex |dtime |ftime |parent |root\n"); printf("-------|------|------|-------|-----\n"); for (int i = 0; i < n; i++) printf("%7d|%6d|%6d|%7d|%5d\n", i + 1, discoverTime2[i], finishTime2[i], parent2[i], dfstRoot[i]); printf("\n"); /* FREE MEMORY */ for (int i = 1; i <= n; i++) { for (IntList ptr = adj_list[i]; ptr != intNil; ptr = intRest(ptr)); for (IntList ptr = transpose_list[i]; ptr != intNil; ptr = intRest(ptr)); } free(adj_list); free(transpose_list); }
int main(void) { int i,err; pthread_t threads[THREADSNUM]; TopForumList* topForumList; Cpm** cpm; Gn **gn = NULL; //initialize poolList,mutex and conditionVariable poolList = createPoolList(); pthread_mutex_init(&mtx,0); pthread_cond_init(&cond_nonempty,0); //create THREADSNUM threads for(i=0;i<THREADSNUM;i++) if( (err = pthread_create(&threads[i],NULL,threadFunction,NULL))){ perror2("pthread_create",err); exit(1); } //load graph using files int bucketsNumber = 10; int bucketSize = 5; Graph* g = loadGraph(bucketsNumber, bucketSize); topForumList = PreperationFunction(g,NUMBER_OF_TOP_N_FORUMS); //printTopNForums(topForumList); int cliqueSize[2] = {3, 4}; cpm = computeCPMResults(g,cliqueSize,topForumList); validateCPMResults(cpm); double modularityMax = DBL_MAX; gn = computeGNResults(g,modularityMax,topForumList); validateGNResults(gn); free_memory(topForumList,cpm,gn);//free memory function /* Graph* g = createTempGraph(); EdgeList* edgeList = createEdgeList(); //find all GraphEdges findEdges(g,edgeList); //calculate communities of graph //printf("%d",DBL_MAX); double modularityMax = DBL_MAX; Community* communities = GirvanNewman(modularityMax,g,edgeList); for(int i=0;i<g->communitiesInfo->communitiesNum;i++){ for(int j=0;j<communities[i].numberOfGeneralMembers;j++) printf("member:%d\n",communities[i].generalMembers[j]); fflush(stdout); printf("\n"); } destroyGraph(g); */ //wait until all threads are done with their jobs for(i=0;i<THREADSNUM;i++) if( (err = pthread_join(threads[i],NULL)) ){ perror2("pthread_join",err); exit(1); } //destroy mutex and conditionVariable free(poolList); pthread_cond_destroy(&cond_nonempty); pthread_mutex_destroy(&mtx); return EXIT_SUCCESS; }
int main() { int i; double cl; kase = 1; // The final output will be written in the outFile and the initial input will be read from inFile std::string outFile = "output.txt"; std::string inFile = "input.txt"; // Create the output file FILE *fpout = fopen(outFile.c_str(), "wt"); fclose(fpout); // Open the input file FILE *fpin = fopen(inFile.c_str(), "rt"); // Reading each of the cases, There may be two types of cases, with 4 parameters, with 5 parameters // There may also be comments that starts with # while(fgets(buff, 1000, fpin)) { // No data if(strlen(buff) == 0) continue; // Comment if(buff[0] == '#') continue; StringTokenizer token; // tokeniize using space token.parse(buff, " \n\r"); std::vector<std::string> vecToken; token.getTokens(vecToken); int totParam = vecToken.size(); // Not enough parameters if(totParam < 4) continue; // First token is the graph file name std::string graphFile = vecToken[0]; // 2nd and 3rd tokens are start and end node id respectively int startNode = atoi(vecToken[1].c_str()); int endNode = atoi(vecToken[2].c_str()); // 4th Token is the result file for this query std::string pathFile = vecToken[3]; int ind = pathFile.length() - 1; while(pathFile[ind] < 32) { pathFile[ind] = '\0'; ind--; } // Load edge information from graph file loadGraph(graphFile); // Use bidirectional AStar to get the route BiDirAStar gdef; cl = clock(); int res = gdef.bidir_astar(edges, edge_count, maxNode, startNode, endNode, &path, &path_count, &err_msg); cl = clock() - cl; // Write the route in the result file write_result(pathFile, res); // There is an answer file if(totParam > 4) { std::string ansFile = vecToken[4]; ind = ansFile.length() - 1; while(ansFile[ind] < 32) { ansFile[ind] = '\0'; ind--; } // Match and write result in the final output file match(pathFile, ansFile, outFile, cl / CLOCKS_PER_SEC); } else { // Provide information that the route is generated in path file. fpout = fopen(outFile.c_str(), "a+"); fprintf(fpout, "Case %d: Path Written to file %s", kase, pathFile.c_str()); fprintf(fpout, "Query Time: %lf sec\n\n", cl / CLOCKS_PER_SEC); fclose(fpout); } kase++; free(path); delete [] edges; } return 0; }
/******************************************************************** * Other constructor ********************************************************************/ Scan::Scan(uint t, std::string filename) { num_clusters = 0; type = t; loadGraph(filename); }
int main_part2(void) { //firstly execute a test for centrality metrics on small graphs int m = 2; int c = 3; testBetweennessCentrality(m, c); testClosenessCentrality(m, c); //small example for trust graph estimation testTidalTrust(m, c); /*create graph from file*/ int bucketsNumber = 5; int bucketSize = 10; Graph* g = loadGraph(bucketsNumber, bucketSize); //graph metrics calls //plot the graph degree distribution degreeDistribution(g, false); int diam = diameter(g); CHECKINT("Graph diameter", diam, 14); double avgPthLgth = averagePathLength(g); CHECKDOUBLE("Graph average path length", avgPthLgth, 5.0753); int ccNumber = numberOfCCs(g); CHECKINT("Graph number of components ", ccNumber, 1); int maximumCC = maxCC(g); CHECKINT("Graph maximum connected component ", maximumCC, 111); double dense = density(g); CHECKDOUBLE("Graph density ", dense, 0.073); /* * WRONG CALCULATIONS - only considering neighbors and not multi-step paths! int closenessIds[5] = { 1734, 38, 8899, 3501, 75}; float closenessIdsRes[5] = {0.109, 0.090, 0.072, 0.045, 0.009}; for (i = 0; i < 5; ++i) { int nodeID = closenessIds[i]; Node* node = lookupNode(nodeID, g); double closCentrty = closenessCentrality(node, g); CHECKDOUBLE("Graph closeness centrality ", closCentrty, closenessIdsRes[i]); } */ int i, k; int betweennessIds[5] = { 1734, 38, 8899, 9900, 75}; float betweennessIdsRes[5] = { 0.306, 0.053, 0.018, 0.005, 0.000}; for (i = 0; i < 5; ++i) { int nodeID = betweennessIds[i]; Node* node = lookupNode(nodeID, g); double betwCentrty = betweennessCentrality(node, g); CHECKDOUBLE("Graph betweenness centrality ", betwCentrty, betweennessIdsRes[i]); } //graph queries calls // Query 1 // Matches* match; Node *dateNode = lookupNode(3755, g); int commonInterests = 1, ageDiff = 30, acquaintanceHops = 3, matchesNum = 1; match = matchSuggestion(dateNode, commonInterests, acquaintanceHops, ageDiff, matchesNum, g); //match result : 7107 - work_at_organization: 1650 //get first pair's person ids int id1 = getMatch(0, match); CHECKINT("Query 1: Date result 1st id", id1, 7107); delete match; // Query 2 // //estimate stalkers graph with closeness centrality Graph* stalkersGraphCloseCentr; int stalkersNum = 7, likesNumber = 1, centralityMode = 1; Stalkers* stalkersCloseCentr = new Stalkers(stalkersNum); stalkersGraphCloseCentr = getTopStalkers(stalkersNum, likesNumber, centralityMode, g, stalkersCloseCentr); int stalkersResultsIds[] = {347, 495, 7768, 8354, 8403, 8899, 9633}; int stalkerResultSize = 7; int stalkerID; int counter = 0; for (int i = 0; i < stalkersNum; ++i) { stalkerID = getStalkerID(i, stalkersCloseCentr); if (stalkerID != -1) { ++counter; } for (k = 0; k < stalkerResultSize; ++k) { if (stalkersResultsIds[k] == stalkerID) { break; } } if (k == stalkerResultSize) { printf("You wrongly labeled person with id %d as Stalker\n", stalkerID); } } CHECKINT("Query 2: Stalker closeness results size", stalkerResultSize, counter); //run metrics on stalker-graph stalkersGraphRunMetrics(stalkersGraphCloseCentr); //estimate stalkers graph with betweenness centrality Graph* stalkersGraphBetwCentr; Stalkers* stalkersBetwCentr = new Stalkers(stalkersNum); centralityMode = 2; stalkersGraphBetwCentr = getTopStalkers(stalkersNum, likesNumber, centralityMode, g, stalkersBetwCentr); counter = 0; for (int i = 0; i < stalkersNum; ++i) { stalkerID = getStalkerID(i, stalkersBetwCentr); if (stalkerID != -1) { ++counter; } for (k = 0; k < stalkerResultSize; ++k) { if (stalkersResultsIds[k] == stalkerID) { break; } } if (k == stalkerResultSize) { printf("You wrongly labeled person with id %d as Stalker\n", stalkerID); } } CHECKINT("Query 2: Stalker betweenness results size", stalkerResultSize, counter); //run metrics on stalker-graph stalkersGraphRunMetrics(stalkersGraphBetwCentr); // Query 3 - Correct// int trendsNum = 4; //allocate result tables before calling query and pass them as parameters char** womenTrends; womenTrends = (char**) malloc(trendsNum * sizeof (char*)); char** menTrends; menTrends = (char**) malloc(trendsNum * sizeof (char*)); findTrends(trendsNum, g, &womenTrends, &menTrends); printf("Top Women - Men Trends\n"); int j; char* menTrendsResults[4] = {"Sun_Yat-sen", "Constantine_the_Great","Sigmund_Freud", "Hussein_of_Jordan"}; //IDS: {417,11622,468,1398} char* womenTrendsResults[4] = {"Adolf_Hitler", "Chiang_Kai-shek", NULL, NULL}; //IDS: {138,416,null,null} int counterW = 0, counterM = 0; for (j = 0; j < 4; ++j) { if (menTrends[j] != NULL) { ++counterM; for (k = 0; k < 4; ++k) { if (strcmp(menTrends[j], menTrendsResults[k]) == 0) { break; } } if (k == 4) { printf("You wrongly labeled tag with %s as top trend\n", menTrends[j]); } } } CHECKINT("Query 3: Mens Trends result size", 4, counterM); for (j = 0; j < 4; ++j) { if (womenTrends[j] != NULL) { ++counterW; for (k = 0; k < 2; ++k) { if (strcmp(womenTrends[j], womenTrendsResults[k]) == 0) { break; } } if (k == 2) { printf("You wrongly labeled tag with %s as top trend\n", menTrends[j]); } } } CHECKINT("Query 3: Women Trends result size", 2, counterW); cout<<"_____________________________________"<<endl; // Query 4 // // int forumID = 34680; char *forumName = "Wall of Xiomara Fernandez"; Graph *trustGraph = buildTrustGraph(forumName, g); int trustANodeId = 30; int trustBNodeId = 9805; int trustCNodeId = 9700; Node *ta = lookupNode(trustANodeId, trustGraph); assert(ta != NULL); Node *tb = lookupNode(trustBNodeId, trustGraph); assert(tb != NULL); Node *tc = lookupNode(trustCNodeId, trustGraph); assert(tc != NULL); double trustAB; trustAB = estimateTrust(ta, tb, trustGraph); printf("Trust between nodes (%d,%d) is %f\n", trustANodeId, trustBNodeId, trustAB); CHECKDOUBLE("Trust: (30,9805) ", trustAB, 0.134); cout<<"_____________________________________"<<endl; double trustAC; trustAC = estimateTrust(ta,tc, trustGraph); printf("Trust between nodes (%d,%d) is %f\n", trustANodeId, trustCNodeId, trustAC); CHECKDOUBLE("Trust: (30,9700) ", trustAC, 0.15); return EXIT_SUCCESS; }