PUNGraph GetEgonet(const PUNGraph& Graph, const int CtrNId, int& ArndEdges) { PUNGraph NewGraphPt = TUNGraph::New(); TUNGraph& NewGraph = *NewGraphPt; NewGraph.AddNode(CtrNId); const TUNGraph::TNodeI& CtrNode = Graph->GetNI(CtrNId); for (int i = 0; i < CtrNode.GetInDeg(); ++i) { NewGraph.AddNode(CtrNode.GetInNId(i)); } ArndEdges = 0; for (int i = 0; i < CtrNode.GetInDeg(); ++i) { int NbrNId = CtrNode.GetInNId(i); const TUNGraph::TNodeI& NbrNode = Graph->GetNI(NbrNId); for (int j = 0; j < NbrNode.GetInDeg(); ++j) { int NbrNbrNId = NbrNode.GetInNId(j); if (NewGraph.IsNode(NbrNbrNId)) { if (!NewGraph.IsEdge(NbrNId, NbrNbrNId)) { NewGraph.AddEdge(NbrNId, NbrNbrNId); } } else { ArndEdges++; } } } return NewGraphPt; }
double GetGroupDegreeCentr(const PUNGraph& Graph, const PUNGraph& Group) { int deg; TIntH NN; for (TUNGraph::TNodeI NI = Group->BegNI(); NI < Group->EndNI(); NI++) { deg = Graph->GetNI(NI.GetId()).GetDeg(); for (int i = 0; i<deg; i++) { if (Group->IsNode(Graph->GetNI(NI.GetId()).GetNbrNId(i)) == 0) NN.AddDat(Graph->GetNI(NI.GetId()).GetNbrNId(i), NI.GetId()); } } return (double)NN.Len(); }
double GetGroupDegreeCentr0(const PUNGraph& Graph, const TIntH& GroupNodes) { int deg; TIntH NN; for (int i = 0; i<GroupNodes.Len(); i++) { deg = Graph->GetNI(GroupNodes.GetDat(i)).GetDeg(); for (int j = 0; j < deg; j++) { if (GroupNodes.IsKey(Graph->GetNI(GroupNodes.GetDat(i)).GetNbrNId(j)) == 0) NN.AddDat(Graph->GetNI(GroupNodes.GetDat(i)).GetNbrNId(j), GroupNodes.GetDat(i)); } } return (double)NN.Len(); }
int ComputeKCore(const PUNGraph& G) { int cnt = 0; for(TUNGraph::TNodeI NI = G->BegNI(); NI < G->EndNI(); NI++) cnt = max(cnt, NI.GetOutDeg()); THashSet <TInt> D[cnt+1]; THash <TInt, TInt> deg; for(TUNGraph::TNodeI NI = G->BegNI(); NI < G->EndNI(); NI++) { TInt tmp = NI.GetOutDeg() - G->IsEdge(NI.GetId(), NI.GetId() ); D[tmp.Val].AddKey(NI.GetId()); deg.AddDat(NI.GetId()) = tmp; } int max_k = 0; for(int num_iters = 0;num_iters < G->GetNodes(); num_iters++) for(int i = 0; i < cnt; i++) if(D[i].Empty() == 0) { max_k = max(max_k, i); TInt a = *(D[i].BegI()); D[i].DelKey(a); deg.AddDat(a.Val) = -1; // Hope overwriting works TUNGraph::TNodeI NI = G->GetNI(a.Val); for(int e = 0; e < NI.GetOutDeg(); e++) { TInt b = NI.GetOutNId(e); if(deg.GetDat(b) >= 0) { int Id = deg.GetKeyId(b); D[deg[Id].Val].DelKey(b); deg[Id] = deg[Id] - 1; //Hope the overwriting works D[deg[Id]].AddKey(b); } } break; } return max_k; }
double TAGMUtil::GetConductance(const PUNGraph& Graph, const TIntSet& CmtyS, const int Edges) { const int Edges2 = Edges >= 0 ? 2*Edges : Graph->GetEdges(); int Vol = 0, Cut = 0; double Phi = 0.0; for (int i = 0; i < CmtyS.Len(); i++) { if (! Graph->IsNode(CmtyS[i])) { continue; } TUNGraph::TNodeI NI = Graph->GetNI(CmtyS[i]); for (int e = 0; e < NI.GetOutDeg(); e++) { if (! CmtyS.IsKey(NI.GetOutNId(e))) { Cut += 1; } } Vol += NI.GetOutDeg(); } // get conductance if (Vol != Edges2) { if (2 * Vol > Edges2) { Phi = Cut / double (Edges2 - Vol); } else if (Vol == 0) { Phi = 0.0; } else { Phi = Cut / double(Vol); } } else { if (Vol == Edges2) { Phi = 1.0; } } return Phi; }
void TAGMUtil::GetNbhCom(const PUNGraph& Graph, const int NID, TIntSet& NBCmtyS) { TUNGraph::TNodeI NI = Graph->GetNI(NID); NBCmtyS.Gen(NI.GetDeg()); NBCmtyS.AddKey(NID); for (int e = 0; e < NI.GetDeg(); e++) { NBCmtyS.AddKey(NI.GetNbrNId(e)); } }
// RenumberNodes ... Renumber node ids in the subgraph to 0...N-1 PUNGraph GetSubGraph(const PUNGraph& Graph, const TIntV& NIdV, const bool& RenumberNodes) { //if (! RenumberNodes) { return TSnap::GetSubGraph(Graph, NIdV); } PUNGraph NewGraphPt = TUNGraph::New(); TUNGraph& NewGraph = *NewGraphPt; NewGraph.Reserve(NIdV.Len(), -1); TIntSet NIdSet(NIdV.Len()); for (int n = 0; n < NIdV.Len(); n++) { if (Graph->IsNode(NIdV[n])) { NIdSet.AddKey(NIdV[n]); if (! RenumberNodes) { NewGraph.AddNode(NIdV[n]); } else { NewGraph.AddNode(NIdSet.GetKeyId(NIdV[n])); } } } if (! RenumberNodes) { for (int n = 0; n < NIdSet.Len(); n++) { const int SrcNId = NIdSet[n]; const TUNGraph::TNodeI NI = Graph->GetNI(SrcNId); for (int edge = 0; edge < NI.GetOutDeg(); edge++) { const int OutNId = NI.GetOutNId(edge); if (NIdSet.IsKey(OutNId)) { NewGraph.AddEdge(SrcNId, OutNId); } } } } else { for (int n = 0; n < NIdSet.Len(); n++) { const int SrcNId = NIdSet[n]; const TUNGraph::TNodeI NI = Graph->GetNI(SrcNId); for (int edge = 0; edge < NI.GetOutDeg(); edge++) { const int OutNId = NI.GetOutNId(edge); if (NIdSet.IsKey(OutNId)) { NewGraph.AddEdge(NIdSet.GetKeyId(SrcNId), NIdSet.GetKeyId(OutNId)); } } } } return NewGraphPt; }
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; }
// Connected components of a graph define clusters // OutDegH and OrigEdges stores node degrees and number of edges in the original graph double _GirvanNewmanGetModularity(const PUNGraph& G, const TIntH& OutDegH, const int& OrigEdges, TCnComV& CnComV) { TSnap::GetWccs(G, CnComV); // get communities double Mod = 0; for (int c = 0; c < CnComV.Len(); c++) { const TIntV& NIdV = CnComV[c](); double EIn=0, EEIn=0; for (int i = 0; i < NIdV.Len(); i++) { TUNGraph::TNodeI NI = G->GetNI(NIdV[i]); EIn += NI.GetOutDeg(); EEIn += OutDegH.GetDat(NIdV[i]); } Mod += (EIn-EEIn*EEIn/(2.0*OrigEdges)); } if (Mod == 0) { return 0; } else { return Mod/(2.0*OrigEdges); } }
// network cascade: add spurious edges // for more details see "Correcting for Missing Data in Information Cascades" by E. Sadikov, M. Medina, J. Leskovec, H. Garcia-Molina. WSDM, 2011 PNGraph AddSpuriousEdges(const PUNGraph& Graph, const PNGraph& Casc, TIntH NIdTmH) { TIntPrV EdgeV; for (TNGraph::TNodeI NI = Casc->BegNI(); NI < Casc->EndNI(); NI++) { TUNGraph::TNodeI GNI = Graph->GetNI(NI.GetId()); const int Tm = NIdTmH.GetDat(NI.GetId()); for (int i=0,j=0; i < GNI.GetOutDeg(); i++) { const int Dst = GNI.GetOutNId(i); if (NIdTmH.IsKey(Dst) && Tm<NIdTmH.GetDat(Dst) && ! NI.IsNbhNId(Dst)) { EdgeV.Add(TIntPr(GNI.GetId(), Dst)); } } } PNGraph NetCasc = TNGraph::New(); *NetCasc = *Casc; for (int e = 0; e < EdgeV.Len(); e++) { NetCasc->AddEdge(EdgeV[e].Val1, EdgeV[e].Val2); } return NetCasc; }
/// Generates a random scale-free graph using the Geometric Preferential /// Attachment model by Flexman, Frieze and Vera. /// See: A geometric preferential attachment model of networks by Flexman, /// Frieze and Vera. WAW 2004. /// URL: http://math.cmu.edu/~af1p/Texfiles/GeoWeb.pdf PUNGraph GenGeoPrefAttach(const int& Nodes, const int& OutDeg, const double& Beta, TRnd& Rnd) { PUNGraph G = TUNGraph::New(Nodes, Nodes*OutDeg); TFltTrV PointV(Nodes, 0); TFltV ValV; // points on a sphere of radius 1/(2*pi) const double Rad = 0.5 * TMath::Pi; for (int i = 0; i < Nodes; i++) { TSnapDetail::GetSphereDev(3, Rnd, ValV); PointV.Add(TFltTr(Rad*ValV[0], Rad*ValV[1], Rad*ValV[2])); } const double R2 = TMath::Sqr(log((double) Nodes) / (pow((double) Nodes, 0.5-Beta))); TIntV DegV, NIdV; int SumDeg; for (int t = 0; t < Nodes; t++) { const int pid = t; const TFltTr& P1 = PointV[pid]; // add node if (! G->IsNode(pid)) { G->AddNode(pid); } // find neighborhood DegV.Clr(false); NIdV.Clr(false); SumDeg=0; for (int p = 0; p < t; p++) { const TFltTr& P2 = PointV[p]; if (TMath::Sqr(P1.Val1-P2.Val1)+TMath::Sqr(P1.Val2-P2.Val2)+TMath::Sqr(P1.Val3-P2.Val3) < R2) { NIdV.Add(p); DegV.Add(G->GetNI(p).GetDeg()+1); SumDeg += DegV.Last(); } } // add edges for (int m = 0; m < OutDeg; m++) { const int rnd = Rnd.GetUniDevInt(SumDeg); int sum = 0, dst = -1; for (int s = 0; s < DegV.Len(); s++) { sum += DegV[s]; if (rnd < sum) { dst=s; break; } } if (dst != -1) { G->AddEdge(pid, NIdV[dst]); SumDeg -= DegV[dst]; NIdV.Del(dst); DegV.Del(dst); } } } return G; }
void Init(const PUNGraph& Graph) { const double M = 0.5/Graph->GetEdges(); // 1/2m Q = 0.0; for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) { CmtyIdUF.Add(NI.GetId()); const int OutDeg = NI.GetOutDeg(); if (OutDeg == 0) { continue; } TCmtyDat& Dat = CmtyQH.AddDat(NI.GetId(), TCmtyDat(M * OutDeg, OutDeg)); for (int e = 0; e < NI.GetOutDeg(); e++) { const int DstNId = NI.GetOutNId(e); const double DstMod = 2 * M * (1.0 - OutDeg * Graph->GetNI(DstNId).GetOutDeg() * M); Dat.AddQ(DstNId, DstMod); } Q += -1.0*TMath::Sqr(OutDeg*M); if (NI.GetId() < Dat.GetMxQNId()) { MxQHeap.Add(TFltIntIntTr(Dat.GetMxQ(), NI.GetId(), Dat.GetMxQNId())); } } MxQHeap.MakeHeap(); }
double GetGroupDegreeCentr(const PUNGraph& Graph, const TIntH& GroupNodes) { int deg; TIntH NN; TIntH GroupNodes1; for (THashKeyDatI<TInt, TInt> NI = GroupNodes.BegI(); NI < GroupNodes.EndI(); NI++) GroupNodes1.AddDat(NI.GetDat(), NI.GetDat()); for (THashKeyDatI<TInt, TInt> NI = GroupNodes1.BegI(); NI < GroupNodes1.EndI(); NI++){ TUNGraph::TNodeI node = Graph->GetNI(NI.GetKey()); deg = node.GetDeg(); for (int j = 0; j < deg; j++){ if (GroupNodes1.IsKey(node.GetNbrNId(j)) == 0 && NN.IsKey(node.GetNbrNId(j)) == 0) NN.AddDat(node.GetNbrNId(j), NI.GetKey()); } } return (double)NN.Len(); }
// simulate SI model cascade using infection probability Beta until the cascade stops or reaches size MxCascSz PNGraph RunSICascade2(PUNGraph G, const double& Beta, const int& MxCascSz, TIntH& NIdInfTmH) { PNGraph Casc = TNGraph::New(); const int StartNId = G->GetRndNId(); Casc->AddNode(StartNId); NIdInfTmH.AddDat(StartNId, NIdInfTmH.Len()); TIntQ Q; Q.Push(StartNId); while (! Q.Empty()) { const TUNGraph::TNodeI NI = G->GetNI(Q.Top()); Q.Pop(); for (int i = 0; i < NI.GetOutDeg(); i++) { if (TInt::Rnd.GetUniDev() < Beta && ! NIdInfTmH.IsKey(NI.GetOutNId(i))) { Casc->AddNode(NI.GetOutNId(i)); NIdInfTmH.AddDat(NI.GetOutNId(i), NIdInfTmH.Len()); Casc->AddEdge(NI.GetId(), NI.GetOutNId(i)); if (Casc->GetNodes() == MxCascSz) { return Casc; } Q.Push(NI.GetOutNId(i)); } } } return Casc; }
// simulate SI model cascade using infection probability Beta until the cascade reaches size CascSz PNGraph RunSICascade(PUNGraph G, const double& Beta, const int& CascSz, TIntH& NIdInfTmH) { PNGraph Casc = TNGraph::New(); const int StartId = G->GetRndNId(); Casc->AddNode(StartId); NIdInfTmH.AddDat(StartId, NIdInfTmH.Len()); for (int X = 0; X < 10*CascSz; X++) { TIntV CascNIdV; Casc->GetNIdV(CascNIdV); for (int n = 0; n < CascNIdV.Len(); n++) { const TUNGraph::TNodeI NI = G->GetNI(CascNIdV[n]); for (int i = 0; i < NI.GetOutDeg(); i++) { if (Casc->IsNode(NI.GetOutNId(i))) { continue; } if (TInt::Rnd.GetUniDev() < Beta) { Casc->AddNode(NI.GetOutNId(i)); NIdInfTmH.AddDat(NI.GetOutNId(i), NIdInfTmH.Len()); Casc->AddEdge(NI.GetId(), NI.GetOutNId(i)); if (Casc->GetNodes() == CascSz) { return Casc; } } } } } return Casc; }
void GetBetweennessCentr(const PUNGraph& Graph, const TIntV& BtwNIdV, TIntFltH& NodeBtwH, const bool& DoNodeCent, TIntPrFltH& EdgeBtwH, const bool& DoEdgeCent) { if (DoNodeCent) { NodeBtwH.Clr(); } if (DoEdgeCent) { EdgeBtwH.Clr(); } const int nodes = Graph->GetNodes(); TIntS S(nodes); TIntQ Q(nodes); TIntIntVH P(nodes); // one vector for every node TIntFltH delta(nodes); TIntH sigma(nodes), d(nodes); // init for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) { if (DoNodeCent) { NodeBtwH.AddDat(NI.GetId(), 0); } if (DoEdgeCent) { for (int e = 0; e < NI.GetOutDeg(); e++) { if (NI.GetId() < NI.GetOutNId(e)) { EdgeBtwH.AddDat(TIntPr(NI.GetId(), NI.GetOutNId(e)), 0); } } } sigma.AddDat(NI.GetId(), 0); d.AddDat(NI.GetId(), -1); P.AddDat(NI.GetId(), TIntV()); delta.AddDat(NI.GetId(), 0); } // calc betweeness for (int k = 0; k < BtwNIdV.Len(); k++) { const TUNGraph::TNodeI NI = Graph->GetNI(BtwNIdV[k]); // reset for (int i = 0; i < sigma.Len(); i++) { sigma[i] = 0; d[i] = -1; delta[i] = 0; P[i].Clr(false); } S.Clr(false); Q.Clr(false); sigma.AddDat(NI.GetId(), 1); d.AddDat(NI.GetId(), 0); Q.Push(NI.GetId()); while (!Q.Empty()) { const int v = Q.Top(); Q.Pop(); const TUNGraph::TNodeI NI2 = Graph->GetNI(v); S.Push(v); const int VDat = d.GetDat(v); for (int e = 0; e < NI2.GetOutDeg(); e++) { const int w = NI2.GetOutNId(e); if (d.GetDat(w) < 0) { // find w for the first time Q.Push(w); d.AddDat(w, VDat + 1); } //shortest path to w via v ? if (d.GetDat(w) == VDat + 1) { sigma.AddDat(w) += sigma.GetDat(v); P.GetDat(w).Add(v); } } } while (!S.Empty()) { const int w = S.Top(); const double SigmaW = sigma.GetDat(w); const double DeltaW = delta.GetDat(w); const TIntV NIdV = P.GetDat(w); S.Pop(); for (int i = 0; i < NIdV.Len(); i++) { const int nid = NIdV[i]; const double c = (sigma.GetDat(nid)*1.0 / SigmaW) * (1 + DeltaW); delta.AddDat(nid) += c; if (DoEdgeCent) { EdgeBtwH.AddDat(TIntPr(TMath::Mn(nid, w), TMath::Mx(nid, w))) += c; } } if (DoNodeCent && w != NI.GetId()) { NodeBtwH.AddDat(w) += delta.GetDat(w) / 2.0; } } } }
// Maximum Domination Problem void MaxCPGreedyBetter(const PUNGraph& Graph, const int k, TIntH& GroupNodes) { // buildup cpntainer of group nodes const int n = Graph->GetNodes(); int *NNodes = new int[n]; // container of neighbouring nodes int NNodes_br = 0; TIntH Nodes; // nodes sorted by vd double gc = 0, gc0 = 0; int addId = 0, addIdPrev = 0; for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++){ Nodes.AddDat(NI.GetId(), NI.GetDeg()); } Nodes.SortByDat(false); int br = 0; while (br < k) { for (THashKeyDatI<TInt, TInt> NI = Nodes.BegI(); NI < Nodes.EndI(); NI++){ if ((NI.GetDat() <= (int)gc0)) break; gc = NI.GetDat() - Intersect(Graph->GetNI(NI.GetKey()), NNodes, NNodes_br); if (gc>gc0){ gc0 = gc; addId = NI.GetKey(); } } if (addId != addIdPrev) { GroupNodes.AddDat(br, addId); br++; gc0 = 0; int nn = addId; bool nnnew = true; for (int j = 0; j<NNodes_br; j++) if (NNodes[j] == nn){ nnnew = false; j = NNodes_br; } if (nnnew){ NNodes[NNodes_br] = nn; NNodes_br++; } for (int i = 0; i<Graph->GetNI(addId).GetDeg(); i++) { int nn = Graph->GetNI(addId).GetNbrNId(i); bool nnnew = true; for (int j = 0; j<NNodes_br; j++) { if (NNodes[j] == nn){ nnnew = false; j = NNodes_br; } } if (nnnew){ NNodes[NNodes_br] = nn; NNodes_br++; } } addIdPrev = addId; Nodes.DelKey(addId); } else { br = k; } printf("%i,", br); } delete NNodes; }
///////////////////////////////////////////////// // Node centrality measures double GetDegreeCentr(const PUNGraph& Graph, const int& NId) { if (Graph->GetNodes() > 1) { return double(Graph->GetNI(NId).GetDeg()) / double(Graph->GetNodes() - 1); } else { return 0.0; } }
int main(int argc, char* argv[]) { // const TStr InFNm = Env.GetIfArgPrefixStr("-i:", "graph.txt", "Input graph (one edge per line, tab/space separated)"); // const TBool IsDir = Env.GetIfArgPrefixBool("-d:", true, "Directed graph"); // const TStr OutFNm = Env.GetIfArgPrefixStr("-o:", "graph", "Output file prefix"); // const TStr Desc = Env.GetIfArgPrefixStr("-t:", "", "Title (description)"); // const TStr Plot = Env.GetIfArgPrefixStr("-p:", "cdhwsCvV", "What statistics to plot string:" // "\n\tc: cummulative degree distribution" // "\n\td: degree distribution" // "\n\th: hop plot (diameter)" // "\n\tw: distribution of weakly connected components" // "\n\ts: distribution of strongly connected components" // "\n\tC: clustering coefficient" // "\n\tv: singular values" // "\n\tV: left and right singular vector\n\t"); // bool PlotDD, PlotCDD, PlotHop, PlotWcc, PlotScc, PlotSVal, PlotSVec, PlotClustCf; // PlotDD = Plot.SearchCh('d') != -1; // PlotCDD = Plot.SearchCh('c') != -1; // PlotHop = Plot.SearchCh('h') != -1; // PlotWcc = Plot.SearchCh('w') != -1; // PlotScc = Plot.SearchCh('s') != -1; // PlotClustCf = Plot.SearchCh('C') != -1; // PlotSVal = Plot.SearchCh('v') != -1; // PlotSVec = Plot.SearchCh('V') != -1; // if (Env.IsEndOfRun()) { return 0; } //PNGraph G = TGGen<PNGraph>::GenRMat(1000, 3000, 0.40, 0.25, 0.2); //G->SaveEdgeList("graph.txt", "RMat graph (a:0.40, b:0.25, c:0.20)"); printf("Loading..."); if (argc < 3) return 0; TStr InFNm = argv[1]; TStr prefix = argv[2]; // ostringstream os; // os << InFNm << "_OutDegreeDistribution"; // TStr FNOutDD = os.str(); // os.str(""); // os.clear(); const TStr Desc = prefix; TStr FNOutDD = prefix; // os << InFNm << "_InDegreeDistribution"; // TStr FNInDD = os.str(); // os.str(""); // os.clear(); TStr FNInDD = prefix; // os << InFNm << "_HopPlot"; // TStr FNHops = os.str(); // os.str(""); // os.clear(); TStr FNHops = prefix; // os << InFNm << "_WeaklyConnectedComponents"; // TStr FNWeaklyConnectedComps = os.str(); // os.str(""); // os.clear(); TStr FNWeaklyConnectedComps = prefix; // os << InFNm << "_StronglyConnectedComponents"; // TStr FNStronglyConnectedComps = os.str(); // os.str(""); // os.clear(); TStr FNStronglyConnectedComps = prefix; // os << InFNm << "ClusteringCoefficient"; // TStr FNClusteringCoeff = os.str(); // os.str(""); // os.clear(); TStr FNClusteringCoeff = prefix; TStr FNCentrality = prefix + "_centrality.dat"; Env = TEnv(argc, argv, TNotify::StdNotify); Env.PrepArgs(TStr::Fmt("GraphInfo. build: %s, %s. Time: %s", __TIME__, __DATE__, TExeTm::GetCurTm())); TExeTm ExeTm; Try PNGraph Graph = TSnap::LoadEdgeList<PNGraph>(InFNm); // if (! IsDir) { TSnap::MakeUnDir(Graph); } printf("nodes:%d edges:%d\nCreating plots...\n", Graph->GetNodes(), Graph->GetEdges()); // const int Vals = Graph->GetNodes()/2 > 200 ? 200 : Graph->GetNodes()/2; // if (PlotDD) { TSnap::PlotOutDegDistr(Graph, FNOutDD, Desc, false, false); TSnap::PlotInDegDistr(Graph, FNInDD, Desc, false, false); printf("In and Out done\n"); // } // if (PlotCDD) { // TSnap::PlotOutDegDistr(Graph, FNOutCDD, Desc, true, false); // <======== waere interessant // TSnap::PlotInDegDistr(Graph, FNInCDD, Desc, true, false); // } // if (PlotHop) { TSnap::PlotHops(Graph, FNHops, Desc, false, 8); printf("hops done\n"); // } // if (PlotWcc) { TSnap::PlotWccDistr(Graph, FNWeaklyConnectedComps, Desc); printf("wcc done\n"); // } // if (PlotScc) { TSnap::PlotSccDistr(Graph, FNStronglyConnectedComps, Desc); printf("scc done\n"); // } // if (PlotClustCf) { TSnap::PlotClustCf(Graph, FNClusteringCoeff, Desc); printf("CC done\n"); // } // if (PlotSVal) { // TSnap::PlotSngValRank(Graph, Vals, OutFNm, Desc); // } // if(PlotSVec) { // TSnap::PlotSngVec(Graph, OutFNm, Desc); // } PUNGraph UGraph = TSnap::ConvertGraph<PUNGraph>(Graph); TIntFltH BtwH, PRankH, CcfH, CloseH; printf(" PageRank... "); TSnap::GetPageRank(Graph, PRankH, 0.85); printf(" Betweenness (SLOW!)..."); TSnap::GetBetweennessCentr(UGraph, BtwH, 0.1); printf(" Clustering..."); TSnap::GetNodeClustCf(UGraph, CcfH); printf(" Closeness (SLOW!)..."); for (TUNGraph::TNodeI NI = UGraph->BegNI(); NI < UGraph->EndNI(); NI++) { const int NId = NI.GetId(); CloseH.AddDat(NId, TSnap::GetClosenessCentr(UGraph, NId)); } printf("\nDONE! saving..."); FILE *F = fopen(FNCentrality.CStr(), "wt"); fprintf(F,"#Network: %s\n", prefix.CStr()); fprintf(F,"#Nodes: %d\tEdges: %d\n", Graph->GetNodes(), Graph->GetEdges()); fprintf(F,"#NodeId\tDegree\tCloseness\tBetweennes\tClusteringCoefficient\tPageRank\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 ClustCf = CcfH.GetDat(NId); const double PgrCentr = PRankH.GetDat(NId); fprintf(F, "%d\t%f\t%f\t%f\t%f\t%f\n", NId, DegCentr, CloCentr, BtwCentr, ClustCf, PgrCentr); } fclose(F); Catch printf("\nrun time: %s (%s)\n", ExeTm.GetTmStr(), TSecTm::GetCurTm().GetTmStr().CStr()); return 0; }
void sample (const int *m, const int *n, const int *h, const int *ns, const int *in, const int *infection_state, const int *mde, const int *bi, const int *br, double * result) { const int nodes = *h; const int nval = (*n)/2; int num_seeds = *ns; int infect_type = *in; int mode = *mde; int burnin = *bi; int branch = *br; PUNGraph g = get_PUNGraph (m, nval, nodes); THash<TInt, TInt> * visited = choose_seeds (g, num_seeds, infection_state, infect_type); TVec <VisitedNode *> queue; TIntV qids; for (THash<TInt, TInt>::TIter n = visited->BegI(); n != visited->EndI(); n++) { queue = queue + new VisitedNode (n->Key); qids = qids + n->Key; //cerr << "enqueued " << n->Key << endl; } TInt counted = 0; TInt first_unprocessed = 0; TFlt infected_mass = 0.0; TFlt total_mass = 0.0; TFlt revisits = 0.0; TFlt trehits = 0.0; //cerr << "nodeId\tneigh\tnbh_size\tinfected?\tinfected_mass\ttotal_mass" << endl; while (counted < 500 && first_unprocessed < queue.Len()) { VisitedNode * current_node = queue [first_unprocessed]; first_unprocessed++; TUNGraph::TNodeI NI = g->GetNI (current_node->id); TInt neighborhood_size = NI.GetDeg(); // cerr << counted << " " << current_node->id << endl; if (counted >= burnin) { if (infection_state[(current_node->id) - 1] == 1) infected_mass += 1.0/TFlt(neighborhood_size); total_mass += 1.0/TFlt(neighborhood_size); } //cerr << current_node->id << "\t" << neighborhood_size << "\t" << (1.0/TFlt(neighborhood_size)) // << "\t" << infection_state[(current_node->id) - 1] << "\t" << infected_mass << "\t" << total_mass << endl; // build list of unvisited neighbors TVec<TInt> neighbors; for (int i = 0; i < neighborhood_size; i++) { TInt neighbor = NI.GetNbrNId(i); if (mode == 0 && visited->IsKey(neighbor)) continue; else if (mode == 2 && isChild (current_node, neighbor)) continue; else if (mode == 3 && current_node-> previous != NULL && current_node->previous->id == neighbor) continue; else neighbors = neighbors + neighbor; } TInt num_legal_neighbors = neighbors.Len(); TInt sample_size = TMath::Mn<TInt> (branch, num_legal_neighbors); THash <TInt, TInt> * choices = choose (num_legal_neighbors, sample_size); for (THash<TInt, TInt>::TIter n = choices->BegI(); n != choices->EndI(); n++) { if (queue.Len() >= 500) break; queue = queue + new VisitedNode (neighbors[n->Key], current_node); if (visited->IsKey(neighbors[n->Key])) revisits++; if (isChild(current_node, neighbors[n->Key])) trehits++; if (!visited->IsKey(neighbors[n->Key])) qids = qids + neighbors[n->Key]; visited->AddDat(neighbors[n->Key], 1); } counted++; } // cout << (infected_mass / total_mass) << endl; delete (visited); result[0] = (infected_mass / total_mass); result[1] = revisits; result[2] = trehits; result[3] = counted; //PUNGraph p (&g); PUNGraph p = TSnap:: GetSubGraph (g, qids, false); TCnComV convec; result[4] = TSnap::GetClustCf(p, -1); TSnap::GetWccs(p, convec); result[5] = convec.Len(); result[6] = ave_path_length (p); }
int FastCorePeripheryGC(PUNGraph& Graph, TIntIntH& out) { TIntH GroupNodes; // buildup cpntainer of group nodes int *NNodes = new int[Graph->GetNodes()]; // container of neighbouring nodes int NNodes_br = 0; TIntIntH nodes; TIntIntH nodesIds; double Z=0; for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) { // Calculate and store the degrees of each node. int deg = NI.GetDeg(); int id = NI.GetId(); Z += deg; nodes.AddDat(id,deg); } Z = Z/2; nodes.SortByDat(false); // Then sort the nodes in descending order of degree, to get a list of nodes {v1, v2, . . . , vn}. int br1=0; for (THashKeyDatI<TInt,TInt> NI = nodes.BegI(); NI < nodes.EndI(); NI++) { nodesIds.AddDat(NI.GetKey(),NI.GetKey()); br1++; } double Zbest = 99999900000000000; //int kbest; //int olddeg; int br=0; for (int k=0; k<nodes.Len(); k++) { if (k<nodes.Len()-1) { if (nodes[k]==nodes[k+1]) { // go into same deg mode int kmin=-2; int knew=-1; while (kmin < 999999 && kmin !=-1 ) { int kind=-1; knew=k; kmin=999999; while(nodes[k]==nodes[knew] && knew < nodes.Len()-1) { int inter = Intersect(Graph->GetNI(nodesIds[knew]),NNodes,NNodes_br); int deg = nodes[knew]; //if (((((nodes.Len()-NNodes_br)*(nodes.Len()-NNodes_br)))-(nodes.Len()-NNodes_br))/2<(((br*br)-br)/2)) if ((deg-inter)<kmin && !GroupNodes.IsKey(nodesIds[knew])) { kmin = deg-inter; kind = knew; } knew++; } if (kind!=-1) { br++; Z = Z + br - 1 - nodes[kind]; if (Z < (Zbest)) { // or <= //if (olddeg>nodes[kind]) //olddeg = nodes[kind]; Zbest = Z; //kbest = br; int w = nodes[kind]; int id = nodesIds[kind]; GroupNodes.AddDat(id,w); NNodes[NNodes_br] = id; NNodes_br++; } else { break; } } } k=knew-1; } else { br++; Z = Z + br - 1 - nodes[k]; if (Z < (Zbest)) { // or <= //if (olddeg>nodes[k]) //olddeg = nodes[k]; Zbest = Z; //kbest = br; int w = nodes[k]; int id = nodesIds[k]; GroupNodes.AddDat(id,w); NNodes[NNodes_br] = id; NNodes_br++; } } } else { br++; Z = Z + br - 1 - nodes[k]; if (Z < Zbest) { // or <= //if (olddeg>nodes[k]) //olddeg = nodes[k]; Zbest = Z; //kbest = br; int w = nodes[k]; int id = nodesIds[k]; GroupNodes.AddDat(id,w); NNodes[NNodes_br] = id; NNodes_br++; } } } int cp = 0; br = 0; for (THashKeyDatI<TInt, TInt> it = nodes.BegI(); !it.IsEnd(); it++) { if (GroupNodes.IsKey(it.GetKey())) cp = 1; else cp = 0; out.AddDat(it.GetKey(), cp); br++; } /*for (THashKeyDatI<TInt, TInt> it = GroupNodes.BegI(); it < GroupNodes.EndI(); it++) { out.AddDat(it.GetKey(), 1); br++; }*/ //return kbest; return GroupNodes.Len(); }
void GetMotifCount(const PUNGraph& G, const int MotifSize, TVec <int64> & MotifV, const int num) { if (MotifSize == 3) { MotifV = TVec <int64> (2); MotifV.PutAll(0); TSnap::GetTriads(G,MotifV[mtThreeClosed],MotifV[mtThreeOpen],num); } else { MotifV = TVec <int64> (6); MotifV.PutAll(0); TIntPrV V(G->GetEdges(), 0); for (TUNGraph::TEdgeI EI = G->BegEI(); EI < G->EndEI(); EI++) { V.Add(TIntPr(EI.GetSrcNId(), EI.GetDstNId())); } TRnd blargh; V.Shuffle(blargh); for (int z = 0; z < num; z++) { int SrcNId = V[z].Val1.Val, DstNId = V[z].Val2.Val; TUNGraph::TNodeI SrcNI = G->GetNI(SrcNId), DstNI = G->GetNI(DstNId); TIntV SrcV(SrcNI.GetOutDeg(),0), DstV(DstNI.GetOutDeg(),0), BothV(min(SrcNI.GetOutDeg(), DstNI.GetOutDeg()),0); SrcV.Clr(0,-1); DstV.Clr(0,-1); BothV.Clr(0,-1); //Grouping the vertices into sets for (int e = 0; e < SrcNI.GetOutDeg(); e++) { if (SrcNI.GetOutNId(e) == DstNId) continue; if (G->IsEdge(DstNId, SrcNI.GetOutNId(e)) ) { BothV.Add(SrcNI.GetOutNId(e)); } else { SrcV.Add(SrcNI.GetOutNId(e)); } } for (int e = 0; e < DstNI.GetOutDeg(); e++) { if (DstNI.GetOutNId(e) == SrcNId) continue; if (G->IsEdge(SrcNId, DstNI.GetOutNId(e)) == 0) { DstV.Add(DstNI.GetOutNId(e)); } } //Compute Motif 0 and 1 for (int i = 0; i < SrcV.Len(); i++) { for (int j = 0; j < DstV.Len(); j++) { if (G->IsEdge(SrcV[i], DstV[j]) ) { MotifV[mfFourSquare]++; } else MotifV[mfFourLine]++; } } //Compute Motif 2 and 3 for (int i = 0; i < SrcV.Len(); i++) { for (int j = i + 1; j < SrcV.Len(); j++) { if (G->IsEdge(SrcV[i], SrcV[j]) ) { MotifV[mfFourTriangleEdge]++; } else MotifV[mfFourStar]++; } } for (int i = 0; i < DstV.Len(); i++) { for (int j = i + 1; j < DstV.Len(); j++) { if (G->IsEdge(DstV[i], DstV[j]) ) { MotifV[mfFourTriangleEdge]++; } else MotifV[mfFourStar]++; } } //Compute Motif 4 and 5 for (int i = 0; i < BothV.Len(); i++) { for (int j = i + 1; j < BothV.Len(); j++) { if (G->IsEdge(BothV[i], BothV[j]) ) { MotifV[mfFourComplete]++; } else MotifV[mfFourSquareDiag]++; } } } MotifV[mfFourSquare] /= 4ll; MotifV[mfFourStar] /= 3ll; MotifV[mfFourComplete] /= 6ll; } }