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;
}
}
