PNGraph TNGraph::GetSmallGraph() { PNGraph G = TNGraph::New(); for (int i = 0; i < 5; i++) { G->AddNode(i); } G->AddEdge(0,1); G->AddEdge(1,2); G->AddEdge(0,2); G->AddEdge(1,3); G->AddEdge(3,4); G->AddEdge(2,3); return G; }
// DyNetML format, loads all the networks in the file TVec<PNGraph> LoadDyNetGraphV(const TStr& FNm) { TXmlLx XmlLx(TFIn::New(FNm), xspTruncate); TVec<PNGraph> GraphV; THashSet<TStr> NIdStr; while (XmlLx.GetSym()!=xsyEof) { if (XmlLx.Sym==xsySTag && XmlLx.TagNm=="network") { PNGraph G = TNGraph::New(); GraphV.Add(G); XmlLx.GetSym(); while (XmlLx.TagNm=="link") { TStr Str1, Val1, Str2, Val2; XmlLx.GetArg(0, Str1, Val1); XmlLx.GetArg(1, Str2, Val2); IAssert(Str1=="source" && Str2=="target"); NIdStr.AddKey(Val1); NIdStr.AddKey(Val2); const int src=NIdStr.GetKeyId(Val1); const int dst=NIdStr.GetKeyId(Val2); if (! G->IsNode(src)) { G->AddNode(src); } if (! G->IsNode(dst)) { G->AddNode(dst); } G->AddEdge(src, dst); XmlLx.GetSym(); } } } return GraphV; }
void TGStatVec::Add(const PNGraph& Graph, const TSecTm& Time, const TStr& GraphNm) { if (Graph->GetNodes() < (int) TGStatVec::MinNodesEdges) { printf(" ** TGStatVec::Add: graph too small (%d nodes).SKIP\n", Graph->GetNodes()); return; } Add(TGStat::New(Graph, Time, StatFSet, GraphNm)); }
// Test GetLen2Paths: Number of path lengths 2 between pair of nodes TEST(triad, TestGetLen2Paths) { // Test TUNGraph PUNGraph GraphTUN = TriadGetTestTUNGraph(); for (int i = 0; i < GraphTUN->GetNodes(); i++) { for (int j = i + 1; j < GraphTUN->GetNodes(); j++) { VerifyLen2Paths(i, j, TSnap::GetLen2Paths(GraphTUN, i, j), 0); } } // Test TNGraph which is different from undirected due to out neighbors. PNGraph GraphTN = TriadGetTestTNGraph(); for (int i = 0; i < GraphTN->GetNodes(); i++) { for (int j = i + 1; j < GraphTN->GetNodes(); j++) { VerifyLen2Paths(i, j, TSnap::GetLen2Paths(GraphTN, i, j), 1); } } // Test TNEGraph which is different from undirected due to out neighbors. PNEGraph GraphTNE = TriadGetTestTNEGraph(); for (int i = 0; i < GraphTNE->GetNodes(); i++) { for (int j = i + 1; j < GraphTNE->GetNodes(); j++) { VerifyLen2Paths(i, j, TSnap::GetLen2Paths(GraphTNE, i, j), 2); } } }
// Test edge subgraph conversion TEST(subgraph, TestConvertESubGraphs) { PNEGraph NEGraph; PNGraph NGraph; TIntV NIdV; TIntV EIdV; int i; NGraph = GetTestTNGraph(); EXPECT_EQ(20,NGraph->GetNodes()); EXPECT_EQ(60,NGraph->GetEdges()); for (i = 0; i < 20; i += 2) { NIdV.Add(i); } // TODO: fix TSnap::ConvertSubGraph<PUNGraph>(NGraph, NIdV, true), it fails // UNGraph = TSnap::ConvertSubGraph<PUNGraph>(NGraph, NIdV, true); NEGraph = TSnap::ConvertGraph<PNEGraph>(NGraph); EXPECT_EQ(20,NEGraph->GetNodes()); EXPECT_EQ(60,NEGraph->GetEdges()); // select every second edge i = 0; for (TNEGraph::TEdgeI EI = NEGraph->BegEI(); EI < NEGraph->EndEI(); EI++) { if (i == 0) { EIdV.Add(EI.GetId()); } i = (i + 1) % 2; } NGraph = TSnap::ConvertESubGraph<PNGraph>(NEGraph, EIdV); EXPECT_EQ(20,NGraph->GetNodes()); EXPECT_EQ(30,NGraph->GetEdges()); }
void TGStat::TakeStat(const PNGraph& Graph, const TSecTm& _Time, TFSet StatFSet, const TStr& GraphName) { printf("\n===TakeStat: G(%u, %u)\n", Graph->GetNodes(), Graph->GetEdges()); TExeTm ExeTm, FullTm; Time = _Time; GraphNm = GraphName; if (StatFSet.In(gsvNone)) { return; } TakeBasicStat(Graph, false); TakeDiam(Graph, StatFSet, false); if (StatFSet.In(gsdWcc) || StatFSet.In(gsdWccHops) || StatFSet.In(gsvFullDiam) || StatFSet.In(gsvEffWccDiam)) { PNGraph WccGraph = TSnap::GetMxWcc(Graph); TakeBasicStat(WccGraph, true); TakeDiam(WccGraph, StatFSet, true); } // degrees TakeDegDistr(Graph, StatFSet); // components TakeConnComp(Graph, StatFSet); // spectral TakeSpectral(Graph, StatFSet, -1); // clustering coeffient if (StatFSet.In(gsdClustCf) || StatFSet.In(gsvClustCf)) { TakeClustCf(Graph); } if (StatFSet.In(gsdTriadPart)) { TakeTriadPart(Graph); } printf(" [%s]\n", FullTm.GetTmStr()); }
void getNumOfPathsFromVect(const PNGraph& graph, std::vector<int> srcIds, int srcSampleSz, std::vector<int> dstIds, int dstSampleSz, char* fileName) { std::random_shuffle(srcIds.begin(), srcIds.end()); std::random_shuffle(dstIds.begin(), dstIds.end()); std::ofstream outputFile; outputFile.open(fileName); for (int i = 0; i < srcIds.size() && i < srcSampleSz; ++i) { int srcNodeId = srcIds[i]; if (!graph->IsNode(srcNodeId)) continue; for (int j = 0; j < dstIds.size() && j < dstSampleSz; ++j) { int dstNodeId = dstIds[j]; if (!graph->IsNode(dstNodeId)) continue; int shortPath = TSnap::GetShortPath(graph, srcNodeId, dstNodeId, true); if (shortPath > 4 || shortPath <= 2) continue; int numOfPaths = getNumOfIndependentPaths(graph, srcNodeId, dstNodeId); char buffer[100]; sprintf(buffer, "%d\t%d\t%d", srcNodeId, dstNodeId, numOfPaths); std::cout << buffer << std::endl; outputFile << buffer << std::endl; } } outputFile.close(); }
PNGraph GetEgonet(const PNGraph& Graph, const int CtrNId, int& InEdges, int& OutEdges) { PNGraph NewGraphPt = TNGraph::New(); TNGraph& NewGraph = *NewGraphPt; NewGraph.AddNode(CtrNId); const TNGraph::TNodeI& CtrNode = Graph->GetNI(CtrNId); for (int i = 0; i < CtrNode.GetDeg(); ++i) { NewGraph.AddNode(CtrNode.GetNbrNId(i)); } InEdges = 0; OutEdges = 0; for (int i = 0; i < CtrNode.GetDeg(); ++i) { int NbrNId = CtrNode.GetNbrNId(i); const TNGraph::TNodeI& NbrNode = Graph->GetNI(NbrNId); for (int j = 0; j < NbrNode.GetInDeg(); ++j) { int NbrNbrNId = NbrNode.GetInNId(j); if (NewGraph.IsNode(NbrNbrNId)) { NewGraph.AddEdge(NbrNbrNId, NbrNId); } else { InEdges++; } } for (int j = 0; j < NbrNode.GetOutDeg(); ++j) { int NbrNbrNId = NbrNode.GetOutNId(j); if (!NewGraph.IsNode(NbrNbrNId)) { OutEdges++; } } } return NewGraphPt; }
void getDistance(const PNGraph& graph, std::vector<int> srcIds, std::vector<int> dstIds, int sampleSize, TFltPrV& ret) { std::random_shuffle(srcIds.begin(), srcIds.end()); std::random_shuffle(dstIds.begin(), dstIds.end()); int distance[20]; for (int i = 0; i < 20; distance[i++] = 0); int sampleCount = 0; for (int i = 0; i < srcIds.size(); ++i) { int srcNodeId = srcIds[i]; if (!graph->IsNode(srcNodeId)) continue; for (int j = 0; j < dstIds.size(); ++j) { int dstNodeId = dstIds[j]; if (!graph->IsNode(dstNodeId)) continue; int shortDist = TSnap::GetShortPath(graph, srcNodeId, dstNodeId, true); distance[shortDist]++; sampleCount++; printIntArray(distance, 20); } if (sampleCount > sampleSize) break; } for (int i = 0; i < 20; ++i) { ret.Add(TFltPr(i, distance[i])); } }
int getNumOfIndependentPaths(const PNGraph& graph, int srcNodeID, int dstNodeID) { int ret = 0; while (true) { PNGraph bfsGraph = TSnap::GetBfsTree(graph, srcNodeID, true, false); if (!bfsGraph->IsNode(dstNodeID)) { return ret; } printf("%d hops\n", TSnap::GetShortPath(bfsGraph, srcNodeID, dstNodeID, true)); // Go back from dstNode to src int itrNodeId = dstNodeID; while (itrNodeId != srcNodeID) { TNGraph::TNodeI curNode = bfsGraph->GetNI(itrNodeId); int parentNodeId = curNode.GetInNId(0); // Delete Edges // graph->DelEdge(parentNodeId, itrNodeId, true); // Delete Node if (itrNodeId != dstNodeID && itrNodeId != srcNodeID) { graph->DelNode(itrNodeId); } itrNodeId = parentNodeId; } ++ret; } }
// Test node subgraph conversion void TestConvertSubGraphs() { PNGraph NGraph; PUNGraph UNGraph; int N1, N2, N3; int E1, E2, E3; TIntV NIdV; int i; NGraph = GetTestTNGraph(); N1 = NGraph->GetNodes(); E1 = NGraph->GetEdges(); for (i = 0; i < 20; i += 2) { NIdV.Add(i); } // TODO: fix TSnap::ConvertSubGraph<PUNGraph>(NGraph, NIdV, true), it fails // UNGraph = TSnap::ConvertSubGraph<PUNGraph>(NGraph, NIdV, true); UNGraph = TSnap::ConvertSubGraph<PUNGraph>(NGraph, NIdV); N2 = UNGraph->GetNodes(); E2 = UNGraph->GetEdges(); NGraph = TSnap::ConvertSubGraph<PNGraph>(UNGraph, NIdV); N3 = NGraph->GetNodes(); E3 = NGraph->GetEdges(); printf("---- TestConvertSubGraphs -----\n"); printf("nodes: %d,%d,%d, edges: %d,%d,%d\n", N1, N2, N3, E1, E2, E3); printf("\n"); }
bool CheckReciprocity(const PNGraph& G){ for (int i = 0; i < G->GetNodes(); i++){ if (G->GetNI(i).GetInDeg() != G->GetNI(i).GetOutDeg()) return false; } return true; }
///////////////////////////////////////////////// // Trawling the web for emerging communities // graph, left points to right TTrawling::TTrawling(const PNGraph& Graph, const int& MinSupport) : MinSup(MinSupport) { TIntH ItemCntH; for (TNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) { IAssert(NI.GetOutDeg()==0 || NI.GetInDeg()==0); // edges only point from left to right if (NI.GetOutDeg()==0) { continue; } for (int e = 0; e < NI.GetOutDeg(); e++) { ItemCntH.AddDat(NI.GetOutNId(e)) += 1; } } TIntV RightV; for (TNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) { IAssert(NI.GetOutDeg()==0 || NI.GetInDeg()==0); // edges only point from left to right if (NI.GetOutDeg()==0) { continue; } RightV.Clr(false); for (int e = 0; e < NI.GetOutDeg(); e++) { const int itm = NI.GetOutNId(e); // only include items that already are above minimum support if (ItemCntH.GetDat(itm) >= MinSup) { RightV.Add(itm); } } if (! RightV.Empty()) { NIdSetH.AddDat(NI.GetId(), RightV); } } // for (int n = 0; n < NIdSetH.Len(); n++) { const TIntV& Set = NIdSetH[n]; for (int s = 0; s < Set.Len(); s++) { SetNIdH.AddDat(Set[s]).Add(n); } } }
// Test GetCmnNbrs: the number of neighbors in common TEST(triad, TestGetCmnNbrs) { // Test TUNGraph PUNGraph GraphTUN = TriadGetTestTUNGraph(); for (int i = 0; i < GraphTUN->GetNodes(); i++) { for (int j = i + 1; j < GraphTUN->GetNodes(); j++) { VerifyCmnNbrs(i, j, TSnap::GetCmnNbrs(GraphTUN, i, j)); } } // Test TNGraph which is same as undirected. PNGraph GraphTN = TriadGetTestTNGraph(); for (int i = 0; i < GraphTN->GetNodes(); i++) { for (int j = i + 1; j < GraphTN->GetNodes(); j++) { VerifyCmnNbrs(i, j, TSnap::GetCmnNbrs(GraphTN, i, j)); } } // Test TNEGraph which is same as undirected. PNEGraph GraphTNE = TriadGetTestTNEGraph(); for (int i = 0; i < GraphTNE->GetNodes(); i++) { for (int j = i + 1; j < GraphTNE->GetNodes(); j++) { VerifyCmnNbrs(i, j, TSnap::GetCmnNbrs(GraphTNE, i, j)); } } }
void analyzeSimNetProps() { const char *eFName = "epidemicRoutingNetEdges.txt"; const char *pFName = "prophetRoutingNetEdges.txt"; PNGraph eGraph = TSnap::LoadEdgeListStr<PNGraph>(eFName, 0, 1); PNEGraph pGraph = TSnap::LoadEdgeListStr<PNEGraph>(pFName, 0, 1); PNGraph randGraph = TSnap::GenRndGnm<PNGraph>(eGraph->GetNodes(), eGraph->GetEdges(), true, TInt::Rnd); chdir("dot"); for (int i=0; i<10; i++) { TIntV NIdV; for (int j = 0; j < 10; j++) { int randNode = eGraph->GetRndNId(); NIdV.AddUnique(randNode); } // Plot the mesage propagtion in Endroy-Renyi graphs PNGraph randFlow = TSnap::GetSubGraph<PNGraph>(randGraph, NIdV); char randf[50]; sprintf(randf,"%d-erdos.dot",i); TSnap::SaveGViz(randFlow, randf, TStr("Edros-Renyi random graph")); // Now plot epidemic routing PNGraph epidemicFlow = TSnap::GetSubGraph<PNGraph>(eGraph, NIdV); char epf[50]; sprintf(epf,"%d-epidemic.dot",i); TSnap::SaveGViz(epidemicFlow, epf, TStr("Epidemic routing")); } }
// Test GetNodeClustCf (Vector) TEST(triad, TestGetNodeClustCfVector) { // Test TUNGraph PUNGraph GraphTUN = TriadGetTestTUNGraph(); TIntFltH NIdCCfH; TSnap::GetNodeClustCf(GraphTUN, NIdCCfH); for (int i = 0; i < GraphTUN->GetNodes(); i++) { double ClustCf = NIdCCfH.GetDat(i); VerifyNodeClustCf(i, ClustCf); } // TNGraph should be treated as TUNGraph for calculations PNGraph GraphTN = TriadGetTestTNGraph(); NIdCCfH.Clr(); TSnap::GetNodeClustCf(GraphTN, NIdCCfH); for (int i = 0; i < GraphTN->GetNodes(); i++) { double ClustCf = NIdCCfH.GetDat(i); VerifyNodeClustCf(i, ClustCf); } // TNEGraph should be treated as TUNGraph for calculations PNEGraph GraphTNE = TriadGetTestTNEGraph(); NIdCCfH.Clr(); TSnap::GetNodeClustCf(GraphTNE, NIdCCfH); for (int i = 0; i < GraphTNE->GetNodes(); i++) { double ClustCf = NIdCCfH.GetDat(i); VerifyNodeClustCf(i, ClustCf); } }
// Test GetNodeTriads (Open and Closed) TEST(triad, TestGetNodeCOTriads) { // Test TUNGraph PUNGraph GraphTUN = TriadGetTestTUNGraph(); for (int i = 0; i < GraphTUN->GetNodes(); i++) { int ClosedTr = -1, OpenTr = -1; TSnap::GetNodeTriads(GraphTUN, i, ClosedTr, OpenTr); VerifyClosedTriads(i, ClosedTr); VerifyOpenTriads(i, OpenTr); } // Test TNGraph which is treated same as undirected. PNGraph GraphTN = TriadGetTestTNGraph(); for (int i = 0; i < GraphTN->GetNodes(); i++) { int ClosedTr = -1, OpenTr = -1; TSnap::GetNodeTriads(GraphTN, i, ClosedTr, OpenTr); VerifyClosedTriads(i, ClosedTr); VerifyOpenTriads(i, OpenTr); } // Test TNEGraph which is treated same as undirected. PNEGraph GraphTNE = TriadGetTestTNEGraph(); for (int i = 0; i < GraphTNE->GetNodes(); i++) { int ClosedTr = -1, OpenTr = -1; TSnap::GetNodeTriads(GraphTNE, i, ClosedTr, OpenTr); VerifyClosedTriads(i, ClosedTr); VerifyOpenTriads(i, OpenTr); } }
// Test GetNodeClustCf (Specific Node) TEST(triad, TestGetNodeClustCfSpecific) { // Test TUNGraph PUNGraph GraphTUN = TriadGetTestTUNGraph(); for (int i = 0; i < GraphTUN->GetNodes(); i++) { double ClustCf = TSnap::GetNodeClustCf(GraphTUN, i); VerifyNodeClustCf(i, ClustCf); } // TNGraph should be treated as TUNGraph for calculations PNGraph GraphTN = TriadGetTestTNGraph(); for (int i = 0; i < GraphTN->GetNodes(); i++) { double ClustCf = TSnap::GetNodeClustCf(GraphTN, i); VerifyNodeClustCf(i, ClustCf); } // TNEGraph should be treated as TUNGraph for calculations PNEGraph GraphTNE = TriadGetTestTNEGraph(); for (int i = 0; i < GraphTNE->GetNodes(); i++) { double ClustCf = TSnap::GetNodeClustCf(GraphTNE, i); VerifyNodeClustCf(i, ClustCf); } }
// Save directed, undirected and multi-graphs in GraphVizp .DOT format void IOGViz() { const int NNodes = 500; const int NEdges = 2000; const char *FName1 = "demo1.dot.dat", *FName2 = "demo2.dot.dat"; const char *Desc = "Randomly generated GgraphVizp for input/output."; PNGraph GOut; // Can be PNEGraph or PUNGraph GOut = GenRndGnm<PNGraph>(NNodes, NEdges); SaveGViz(GOut, FName1); // Output node IDs as numbers TIntStrH NIdLabelH; // Generate labels for random graph for (TNGraph::TNodeI NI = GOut->BegNI(); NI < GOut->EndNI(); NI++) { NIdLabelH.AddDat(NI.GetId(), TStr::Fmt("Node%d", NI.GetId())); } SaveGViz(GOut, FName2, Desc, NIdLabelH); PrintGStats("IOGViz - In", GOut); }
void PlotSngValRank(const PNGraph& Graph, const int& SngVals, const TStr& FNmPref, TStr DescStr) { TFltV SngValV; TSnap::GetSngVals(Graph, SngVals, SngValV); SngValV.Sort(false); if (DescStr.Empty()) { DescStr = FNmPref; } TGnuPlot::PlotValV(SngValV, "sngVal."+FNmPref, TStr::Fmt("%s. G(%d, %d). Largest eig val = %f", DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges(), SngValV[0].Val), "Rank", "Singular value", gpsLog10XY, false, gpwLinesPoints); }
//GDF Node Formatting std::string GDFNodes(const PNGraph & graph){ std::string nodes; for (PNGraph::TObj::TNodeI NI = graph->BegNI(); NI < graph->EndNI(); NI++){ nodes.append(Helper::intToString(NI.GetId())); nodes.append("\n"); } return nodes; }
void SaveAndPlot(const PNGraph& G, const TStr& name, bool isCum){ TFltPrV in, out; TSnap::GetInDegCnt(G, in); TSnap::GetOutDegCnt(G, out); int nodes = G->GetNodes(), edges = G->GetEdges(); TSnap::PlotDegDistr(in, nodes, edges, name, name, isCum, false, true); TSnap::PlotDegDistr(out, nodes, edges, name, name, isCum, false, false); }
///////////////////////////////////////////////// // TGraphEnumUtils implementation void TGraphEnumUtils::GetNormalizedMap(const PNGraph &G, THash<TInt,TInt> &map) { int nId=0; for(TNGraph::TNodeI it=G->BegNI(); it<G->EndNI(); it++) { //printf("%d -> %d\n", it.GetId(), nId); map.AddDat(it.GetId(), nId); nId++; } }
PNGraph TGraphKey::GetNGraph() const { PNGraph G = TNGraph::New(); for (int i = 0; i < GetNodes(); i++) G->AddNode(i); for (int e = 0; e < GetEdges(); e++) { G->AddEdge(EdgeV[e].Val1, EdgeV[e].Val2); } G->Defrag(); return G; }
/// returns a perfect binary tree PNGraph GetTree() { PNGraph G = TNGraph::New(); for (int i = 0; i < 15; i++) { G->AddNode(i); } for (int i = 1; i < 15; i++) { G->AddEdge(i,i/2); } return G; }
//GDF Edge Formatting std::string GDFEdges(const PNGraph & graph){ std::string edges; for (PNGraph::TObj::TEdgeI EI = graph->BegEI(); EI < graph->EndEI(); EI++){ edges.append(Helper::intToString(EI.GetSrcNId())); edges.append(", "); edges.append(Helper::intToString(EI.GetDstNId())); edges.append("\n"); } return edges; }
void node2vec(PNGraph& InNet, double& ParamP, double& ParamQ, int& Dimensions, int& WalkLen, int& NumWalks, int& WinSize, int& Iter, bool& Verbose, TIntFltVH& EmbeddingsHV) { PWNet NewNet = PWNet::New(); for (TNGraph::TEdgeI EI = InNet->BegEI(); EI < InNet->EndEI(); EI++) { if (!NewNet->IsNode(EI.GetSrcNId())) { NewNet->AddNode(EI.GetSrcNId()); } if (!NewNet->IsNode(EI.GetDstNId())) { NewNet->AddNode(EI.GetDstNId()); } NewNet->AddEdge(EI.GetSrcNId(), EI.GetDstNId(), 1.0); } node2vec(NewNet, ParamP, ParamQ, Dimensions, WalkLen, NumWalks, WinSize, Iter, Verbose, EmbeddingsHV); }
void gdf(PNGraph Graph){ std::ofstream graph; graph.open("graph.gdf"); graph << "nodedef>name VARCHAR\n"; for (TNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) graph << NI.GetId() << ",\n"; graph << "edgedef>node1 VARCHAR,node2 VARCHAR\n"; for (TNGraph::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) graph << EI.GetSrcNId() << "," << EI.GetDstNId() << "\n"; graph.close(); }
uint64 TGraphEnumUtils::GraphId(const PNGraph &G) { int nodes = G->GetNodes(); uint64 id=0; for(TNGraph::TEdgeI it=G->BegEI(); it<G->EndEI(); it++) { int srcId = it.GetSrcNId(); int dstId = it.GetDstNId(); // id += TMath::Pow2(srcId*nodes + dstId); } // return id; }
int main(int argc, char* argv[]) { Env = TEnv(argc, argv, TNotify::StdNotify); Env.PrepArgs(TStr::Fmt("Node Centrality. build: %s, %s. Time: %s", __TIME__, __DATE__, TExeTm::GetCurTm())); TExeTm ExeTm; Try const TStr InFNm = Env.GetIfArgPrefixStr("-i:", "../as20graph.txt", "Input un/directed graph"); const TStr OutFNm = Env.GetIfArgPrefixStr("-o:", "node_centrality.tab", "Output file"); printf("Loading %s...", InFNm.CStr()); PNGraph Graph = TSnap::LoadEdgeList<PNGraph>(InFNm); //PNGraph Graph = TSnap::GenRndGnm<PNGraph>(10, 10); //TGraphViz::Plot(Graph, gvlNeato, InFNm+".gif", InFNm, true); printf("nodes:%d edges:%d\n", Graph->GetNodes(), Graph->GetEdges()); PUNGraph UGraph = TSnap::ConvertGraph<PUNGraph>(Graph); // undirected version of the graph TIntFltH BtwH, EigH, PRankH, CcfH, CloseH, HubH, AuthH; //printf("Computing...\n"); printf("Treat graph as DIRECTED: "); printf(" PageRank... "); TSnap::GetPageRank(Graph, PRankH, 0.85); printf(" Hubs&Authorities..."); TSnap::GetHits(Graph, HubH, AuthH); printf("\nTreat graph as UNDIRECTED: "); printf(" Eigenvector..."); TSnap::GetEigenVectorCentr(UGraph, EigH); printf(" Clustering..."); TSnap::GetNodeClustCf(UGraph, CcfH); printf(" Betweenness (SLOW!)..."); TSnap::GetBetweennessCentr(UGraph, BtwH, 1.0); printf(" Constraint (SLOW!)..."); TNetConstraint<PUNGraph> NetC(UGraph, true); printf(" Closeness (SLOW!)..."); for (TUNGraph::TNodeI NI = UGraph->BegNI(); NI < UGraph->EndNI(); NI++) { const int NId = NI.GetId(); CloseH.AddDat(NId, TSnap::GetClosenessCentr<PUNGraph>(UGraph, NId, false)); } printf("\nDONE! saving..."); FILE *F = fopen(OutFNm.CStr(), "wt"); fprintf(F,"#Network: %s\n", InFNm.CStr()); fprintf(F,"#Nodes: %d\tEdges: %d\n", Graph->GetNodes(), Graph->GetEdges()); fprintf(F,"#NodeId\tDegree\tCloseness\tBetweennes\tEigenVector\tNetworkConstraint\tClusteringCoefficient\tPageRank\tHubScore\tAuthorityScore\n"); for (TUNGraph::TNodeI NI = UGraph->BegNI(); NI < UGraph->EndNI(); NI++) { const int NId = NI.GetId(); const double DegCentr = UGraph->GetNI(NId).GetDeg(); const double CloCentr = CloseH.GetDat(NId); const double BtwCentr = BtwH.GetDat(NId); const double EigCentr = EigH.GetDat(NId); const double Constraint = NetC.GetNodeC(NId); const double ClustCf = CcfH.GetDat(NId); const double PgrCentr = PRankH.GetDat(NId); const double HubCentr = HubH.GetDat(NId); const double AuthCentr = AuthH.GetDat(NId); fprintf(F, "%d\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\n", NId, DegCentr, CloCentr, BtwCentr, EigCentr, Constraint, ClustCf, PgrCentr, HubCentr, AuthCentr); } fclose(F); Catch printf("\nrun time: %s (%s)\n", ExeTm.GetTmStr(), TSecTm::GetCurTm().GetTmStr().CStr()); return 0; }