void TempMotifCounter::GetAllStaticTriangles(TIntV& Us, TIntV& Vs, TIntV& Ws) {
Us.Clr();
Vs.Clr();
Ws.Clr();
// Get degree ordering of the graph
int max_nodes = static_graph_->GetMxNId();
TVec<TIntPair> degrees(max_nodes);
degrees.PutAll(TIntPair(0, 0));
// Set the degree of a node to be the number of nodes adjacent to the node in
// the undirected graph.
TIntV nodes;
GetAllNodes(nodes);
#pragma omp parallel for schedule(dynamic)
for (int node_id = 0; node_id < nodes.Len(); node_id++) {
int src = nodes[node_id];
TIntV nbrs;
GetAllNeighbors(src, nbrs);
degrees[src] = TIntPair(nbrs.Len(), src);
}
degrees.Sort();
TIntV order = TIntV(max_nodes);
#pragma omp parallel for schedule(dynamic)
for (int i = 0; i < order.Len(); i++) {
order[degrees[i].Dat] = i;
}
// Get triangles centered at a given node where that node is the smallest in
// the degree ordering.
#pragma omp parallel for schedule(dynamic)
for (int node_id = 0; node_id < nodes.Len(); node_id++) {
int src = nodes[node_id];
int src_pos = order[src];
// Get all neighbors who come later in the ordering
TIntV nbrs;
GetAllNeighbors(src, nbrs);
TIntV neighbors_higher;
for (int i = 0; i < nbrs.Len(); i++) {
int nbr = nbrs[i];
if (order[nbr] > src_pos) { neighbors_higher.Add(nbr); }
}
for (int ind1 = 0; ind1 < neighbors_higher.Len(); ind1++) {
for (int ind2 = ind1 + 1; ind2 < neighbors_higher.Len(); ind2++) {
int dst1 = neighbors_higher[ind1];
int dst2 = neighbors_higher[ind2];
// Check for triangle formation
if (static_graph_->IsEdge(dst1, dst2) || static_graph_->IsEdge(dst2, dst1)) {
#pragma omp critical
{
Us.Add(src);
Vs.Add(dst1);
Ws.Add(dst2);
}
}
}
}
}
}
void grafoGDF(PUNGraph G) {
std::ofstream myfile;
std::vector<int> nodos = obtenerVerticesOrdenados(G);
TIntV conexiones;
myfile.open("facebook.gdf");
myfile << "nodedef>name VARCHAR" << "\n";
myfile << "edgedef>node1 VARCHAR,node2 VARCHAR" << "\n";
for (int i = 0; i < nodos.size(); i++) {
GetNodesAtHop(G, nodos[i], 1, conexiones, false);
for (int j = 0; j < conexiones.EndI() - conexiones.BegI(); j++) {
if (conexiones[j] > i) {
myfile << i << "," << conexiones[j] << "\n";
}
}
conexiones.Clr();
}
myfile.close();
}//cierre de grafoGDF
/////////////////////////////////////////////////
// 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);
}
}
}
void TUStr::GetWordUStrV(TUStrV& WordUStrV){
// clear word vector
WordUStrV.Clr();
// create boundaries
TBoolV WordBoundPV; GetWordBoundPV(WordBoundPV);
IAssert(Len()==WordBoundPV.Len()-1);
IAssert((WordBoundPV.Len()>0)&&(WordBoundPV.Last()));
// traverse characters and bounds
int UniChs=Len(); TIntV WordUniChV;
for (int UniChN=0; UniChN<=UniChs; UniChN++){
if ((UniChN==UniChs)||(WordBoundPV[UniChN+1])){ // finish or word-boundary
if (UniChN<UniChs){ // if not finish
// if last-word-char or single-alphabetic-char
if ((!WordUniChV.Empty())||(IsAlphabetic(UniChV[UniChN]))){
WordUniChV.Add(UniChV[UniChN]); // add char
}
}
if (!WordUniChV.Empty()){ // add current word to vector
TUStr WordUStr(WordUniChV); // construct word from char-vector
WordUStrV.Add(WordUStr); // add word to word-vector
WordUniChV.Clr(false); // clear char-vector
}
} else {
// add character to char-vector
WordUniChV.Add(UniChV[UniChN]);
}
}
}
// burn each link independently (forward with FwdBurnProb, backward with BckBurnProb)
void TForestFire::BurnExpFire() {
const double OldFwdBurnProb = FwdBurnProb;
const double OldBckBurnProb = BckBurnProb;
const int NInfect = InfectNIdV.Len();
const TNGraph& G = *Graph;
TIntH BurnedNIdH; // burned nodes
TIntV BurningNIdV = InfectNIdV; // currently burning nodes
TIntV NewBurnedNIdV; // nodes newly burned in current step
bool HasAliveNbrs; // has unburned neighbors
int NBurned = NInfect, NDiedFire=0;
for (int i = 0; i < InfectNIdV.Len(); i++) {
BurnedNIdH.AddDat(InfectNIdV[i]); }
NBurnedTmV.Clr(false); NBurningTmV.Clr(false); NewBurnedTmV.Clr(false);
for (int time = 0; ; time++) {
NewBurnedNIdV.Clr(false);
// for each burning node
for (int node = 0; node < BurningNIdV.Len(); node++) {
const int& BurningNId = BurningNIdV[node];
const TNGraph::TNodeI Node = G.GetNI(BurningNId);
HasAliveNbrs = false;
NDiedFire = 0;
// burn forward links (out-links)
for (int e = 0; e < Node.GetOutDeg(); e++) {
const int OutNId = Node.GetOutNId(e);
if (! BurnedNIdH.IsKey(OutNId)) { // not yet burned
HasAliveNbrs = true;
if (Rnd.GetUniDev() < FwdBurnProb) {
BurnedNIdH.AddDat(OutNId); NewBurnedNIdV.Add(OutNId); NBurned++; }
}
}
// burn backward links (in-links)
if (BckBurnProb > 0.0) {
for (int e = 0; e < Node.GetInDeg(); e++) {
const int InNId = Node.GetInNId(e);
if (! BurnedNIdH.IsKey(InNId)) { // not yet burned
HasAliveNbrs = true;
if (Rnd.GetUniDev() < BckBurnProb) {
BurnedNIdH.AddDat(InNId); NewBurnedNIdV.Add(InNId); NBurned++; }
}
}
}
if (! HasAliveNbrs) { NDiedFire++; }
}
NBurnedTmV.Add(NBurned);
NBurningTmV.Add(BurningNIdV.Len() - NDiedFire);
NewBurnedTmV.Add(NewBurnedNIdV.Len());
//BurningNIdV.AddV(NewBurnedNIdV); // node is burning eternally
BurningNIdV.Swap(NewBurnedNIdV); // node is burning just 1 time step
if (BurningNIdV.Empty()) break;
FwdBurnProb = FwdBurnProb * ProbDecay;
BckBurnProb = BckBurnProb * ProbDecay;
}
BurnedNIdV.Gen(BurnedNIdH.Len(), 0);
for (int i = 0; i < BurnedNIdH.Len(); i++) {
BurnedNIdV.Add(BurnedNIdH.GetKey(i)); }
FwdBurnProb = OldFwdBurnProb;
BckBurnProb = OldBckBurnProb;
}
/////////////////////////////////////////////////
// DMoz-Base
void TDMozBs::GetCatIdV(const TStrV& CatNmV, TIntV& CatIdV) const {
CatIdV.Clr();
for (int CatNmN=0; CatNmN<CatNmV.Len(); CatNmN++){
int CatId=GetCatId(CatNmV[CatNmN]);
if (CatId==-1){
printf("\nWarning: Invalid Category Name ('%s')\n.", CatNmV[CatNmN].CStr());}
CatIdV.Add(CatId);
}
}
// and words to StrH and get a vector of word ids
void TStrUtil::GetAddWIdV(TStrHash<TInt>& StrH, const char *CStr, TIntV& WIdV) {
TChA ChA(CStr);
TVec<char *> WrdV;
TInt WId;
TStrUtil::SplitWords(ChA, WrdV);
WIdV.Clr(false);
for (int w = 0; w < WrdV.Len(); w++) {
WIdV.Add(StrH.AddDatId(WrdV[w]));
}
}
// GIRVAN-NEWMAN algorithm
// 1. The betweenness of all existing edges in the network is calculated first.
// 2. The edge with the highest betweenness is removed.
// 3. The betweenness of all edges affected by the removal is recalculated.
// 4. Steps 2 and 3 are repeated until no edges remain.
// Girvan M. and Newman M. E. J., Community structure in social and biological networks, Proc. Natl. Acad. Sci. USA 99, 7821–7826 (2002)
// Keep removing edges from Graph until one of the connected components of Graph splits into two.
void CmtyGirvanNewmanStep(PUNGraph& Graph, TIntV& Cmty1, TIntV& Cmty2) {
TIntPrFltH BtwEH;
TBreathFS<PUNGraph> BFS(Graph);
Cmty1.Clr(false); Cmty2.Clr(false);
while (true) {
TSnap::GetBetweennessCentr(Graph, BtwEH);
BtwEH.SortByDat(false);
if (BtwEH.Empty()) { return; }
const int NId1 = BtwEH.GetKey(0).Val1;
const int NId2 = BtwEH.GetKey(0).Val2;
Graph->DelEdge(NId1, NId2);
BFS.DoBfs(NId1, true, false, NId2, TInt::Mx);
if (BFS.GetHops(NId1, NId2) == -1) { // two components
TSnap::GetNodeWcc(Graph, NId1, Cmty1);
TSnap::GetNodeWcc(Graph, NId2, Cmty2);
return;
}
}
}
void TGUtil::MakeExpBins(const TIntV& YValV, TIntV& ExpYValV, const double& BinFactor) {
ExpYValV.Clr(true);
int prevI=0;
for (int i = 0; i < YValV.Len(); ) {
ExpYValV.Add(YValV[i]);
i = int(i*BinFactor);
if (i==prevI) { i++; }
prevI = i;
}
}
/////////////////////////////////////////////////
// WordNet-SynSet
void TWnSynSet::GetDstSynSetPV(
const TWnRelType& RelType, TIntV& DstSynSetPV) const {
DstSynSetPV.Clr();
for (int RelN=0; RelN<RelIntIntTrV.Len(); RelN++){
TWnRelType CurRelType=TWnRelType(RelIntIntTrV[RelN].Val1.Val);
if (RelType==CurRelType){
int DstSynSetP=RelIntIntTrV[RelN].Val3;
DstSynSetPV.Add(DstSynSetP);
}
}
}
void TStrUtil::GetWIdV(const TStrHash<TInt>& StrH, const char *CStr, TIntV& WIdV) {
const int NotWId = -1;
TChA ChA(CStr);
TVec<char *> WrdV;
TInt WId;
TStrUtil::SplitWords(ChA, WrdV);
WIdV.Clr(false);
for (int w = 0; w < WrdV.Len(); w++) {
if (StrH.IsKeyGetDat(WrdV[w], WId)) { WIdV.Add(WId); }
else { WIdV.Add(NotWId); }
}
}
void TTrawling::JoinItems(const TIntV& Item1, const TIntV& Item2, TIntV& JoinItem) {
int i = 0, j = 0;
JoinItem.Clr(false);
const int MaxL = Item1.Len()+1;
while (i < Item1.Len()) {
while (j < Item2.Len() && Item2[j] < Item1[i]) {
JoinItem.Add(Item2[j]); j++; }
JoinItem.Add(Item1[i]);
if (j < Item2.Len() && Item1[i] == Item2[j]) { j++; }
i++;
if (JoinItem.Len() > MaxL) { JoinItem.Clr(false); return; }
}
while (j < Item2.Len()) {
JoinItem.Add(Item2[j]); j++;
}
/*if (JoinItem.Len() > 3) {
Dump(Item1, "\n1:");
Dump(Item2, "2:");
Dump(JoinItem, "J:");
}*/
IAssert(JoinItem.IsSorted());
}
void TEvalScore::Parse(const TStr& Str, TIntV& WIdV) {
TStrV TokenV; Tokenize(Str, TokenV); WIdV.Clr();
for (int WdN = 0; WdN < TokenV.Len(); WdN++) {
// get the word string
TStr WdStr = TokenV[WdN];
// get id of the word
int WId = WordH.GetKeyId(WdStr);
// word does not exist yet, add it to the hash table
if (WId == -1) { WId = WordH.AddKey(WdStr); }
// add word to the parsed sentence
WIdV.Add(WId);
}
}
void grafoJSON(PUNGraph G) {
std::ofstream myfile;
std::vector<int> nodos = obtenerVerticesOrdenados(G);
TIntV conexiones;
myfile.open("facebook.json");
myfile << "{ \"graph\": {" << "\n";
myfile << "\"nodes\": [" << "\n";
for (int i = 0; i < nodos.size(); i++) {
myfile << "{ \"id\": \"" << nodos[i] << "\" }";
if (i == nodos.size()-1) {
myfile << " ]," << "\n";
}
else {
myfile << "," << "\n";
}
}
myfile << "\"edges\": [\n";
for (int i = 0; i < nodos.size(); i++) {
GetNodesAtHop(G, nodos[i], 1, conexiones, false);
for (int j = 0; j < conexiones.EndI() - conexiones.BegI(); j++) {
if (conexiones[j] > i) {
myfile << "{ \"source\": \"" << i << "\", \"target\": \"" << conexiones[j] << "\" }";
if (i == nodos.size()-1) {
myfile << " ]" << "\n";
}
else {
myfile << "," << "\n";
}
}
}
conexiones.Clr();
}
myfile << "} }";
myfile.close();
}
void TBlobBs::GenBlockLenV(TIntV& BlockLenV){
BlockLenV.Clr();
for (int P2Exp=0; P2Exp<TB4Def::MxP2Exp; P2Exp++){
BlockLenV.Add(TInt(TB4Def::GetP2(P2Exp)));}
EAssert(int(BlockLenV.Last())<2000000000);
{for (int Len=10; Len<100; Len+=10){BlockLenV.Add(Len);}}
{for (int Len=100; Len<10000; Len+=100){BlockLenV.Add(Len);}}
{for (int Len=10000; Len<100000; Len+=1000){BlockLenV.Add(Len);}}
{for (int Len=100000; Len<1000000; Len+=25000){BlockLenV.Add(Len);}}
{for (int Len=1000000; Len<10000000; Len+=1000000){BlockLenV.Add(Len);}}
{for (int Len=10000000; Len<100000000; Len+=10000000){BlockLenV.Add(Len);}}
BlockLenV.Sort();
}
void TBowFl::LoadLnDocTxt(PBowDocBs BowDocBs, const TStr& LnDocFNm,
TIntV& NewDIdV, const bool& NamedP, const int& MxDocs, const bool& SaveDocP) {
// open line-doc file
NewDIdV.Clr(); TFIn FIn(LnDocFNm); char Ch=' '; int Docs=0;
while (!FIn.Eof()){
Docs++; if ((MxDocs!=-1)&&(Docs>=MxDocs)){break;}
printf("%d\r", Docs);
// document name
TChA DocNm;
Ch=FIn.GetCh();
if (NamedP){
while ((!FIn.Eof())&&(Ch!='\r')&&(Ch!='\n')&&(Ch!=' ')){
DocNm+=Ch; Ch=FIn.GetCh();}
DocNm.Trunc();
if (DocNm.Empty()){Docs--; continue;}
} else {
DocNm = TInt::GetStr(Docs);
}
// categories
TStrV CatNmV;
forever {
while ((!FIn.Eof())&&(Ch==' ')){Ch=FIn.GetCh();}
if (Ch=='!'){
if (!FIn.Eof()){Ch=FIn.GetCh();}
TChA CatNm;
while ((!FIn.Eof())&&(Ch!='\r')&&(Ch!='\n')&&(Ch!=' ')){
CatNm+=Ch; Ch=FIn.GetCh();}
if (!CatNm.Empty()){CatNmV.Add(CatNm);}
} else {
break;
}
}
// document text
TChA DocChA;
while ((!FIn.Eof())&&(Ch!='\r')&&(Ch!='\n')){
DocChA+=Ch; Ch=FIn.GetCh();}
// skip empty documents (empty lines)
if (DocNm.Empty()&&DocChA.Empty()){
continue;}
// add document to document-base
NewDIdV.Add(BowDocBs->AddHtmlDoc(DocNm, CatNmV, DocChA, SaveDocP));
}
// return document-base
BowDocBs->AssertOk();
printf("\n");
}
void TUStr::GetWordUStrLst(TLst<TUStr>& WordUStrV, TLst<TBool> &TerminalV){ //TBoolV& TerminalV){
// clear word vector
WordUStrV.Clr();
// create boundaries
TBoolV WordBoundPV; GetWordBoundPV(WordBoundPV);
//TerminalV.Reserve(WordBoundPV.Len());
IAssert(Len()==WordBoundPV.Len()-1);
IAssert((WordBoundPV.Len()>0)&&(WordBoundPV.Last()));
// traverse characters and bounds
int UniChs=Len(); TIntV WordUniChV;
bool terminal = false;
for (int UniChN=0; UniChN<=UniChs; UniChN++){
if ((UniChN==UniChs)||(WordBoundPV[UniChN+1])){ // finish or word-boundary
if (UniChN<UniChs){ // if not finish
// if last-word-char or single-alphabetic-char
if ((!WordUniChV.Empty())||(IsAlphabetic(UniChV[UniChN]))){
WordUniChV.Add(UniChV[UniChN]); // add char
}
else{
if(WordUStrV.Len() > 0){
if(IsTerminal(UniChV[UniChN])) terminal = true;
}
}
}
if (!WordUniChV.Empty()){ // add current word to vector
TUStr WordUStr(WordUniChV); // construct word from char-vector
WordUStrV.AddBack(WordUStr); // add word to word-vector
WordUniChV.Clr(false); // clear char-vector
if(terminal){ TerminalV.AddBack(true);}
else{ TerminalV.AddBack(false);}
terminal = false;
}
} else {
// add character to char-vector
WordUniChV.Add(UniChV[UniChN]);
}
}
}
/////////////////////////////////////////////////
// BagOfWords-Files
void TBowFl::LoadHtmlTxt(
PBowDocBs BowDocBs, const TStr& FPath, TIntV& NewDIdV,
const bool& RecurseDirP, const int& MxDocs,
const bool& SaveDocP, const PNotify& Notify) {
// prepare file-directory traversal
TStr LcNrFPath=TStr::GetNrFPath(FPath).GetLc();
Notify->OnStatus("Creating Bow from file-path " + FPath + " ...");
TFFile FFile(FPath, "", RecurseDirP);
// traverse files
TStr FNm; int Docs=0; NewDIdV.Clr();
while (FFile.Next(FNm)){
Docs++; if ((MxDocs!=-1)&&(Docs>MxDocs)){break;}
Notify->OnStatus(TStr::Fmt("%d\r", Docs));
// prepare document-name
if (TFile::Exists(FNm)) { //B:
TStr DocNm=FNm.GetLc();
if (DocNm.IsPrefix(LcNrFPath)){
DocNm=DocNm.GetSubStr(LcNrFPath.Len(), DocNm.Len()-1);}
// categories
TStrV CatNmV; TStr CatNm;
if (DocNm.IsChIn('/')){
TStr Str; DocNm.SplitOnCh(CatNm, '/', Str);
} else if (DocNm.IsChIn('\\')){
TStr Str; DocNm.SplitOnCh(CatNm, '\\', Str);
}
if (!CatNm.Empty()){
CatNmV.Add(CatNm);}
// load document-content
TStr DocStr=TStr::LoadTxt(FNm);
// add document to bow
NewDIdV.Add(BowDocBs->AddHtmlDoc(DocNm, CatNmV, DocStr, SaveDocP));
}
}
Notify->OnStatus(TStr::Fmt("%d", Docs));
// return results
Notify->OnStatus("Done.");
BowDocBs->AssertOk();
}
void grafoGEXF(PUNGraph G) {
std::ofstream myfile;
std::vector<int> nodos = obtenerVerticesOrdenados(G);
long int aristas = 0;
TIntV conexiones;
myfile.open("facebook.gexf");
myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << "\n";
myfile << "<gexf xmlns=\"http://www.gexf.net/1.2draft\" version=\"1.2\">" << "\n";
myfile << "\t<graph mode=\"static\" defaultedgetype=\"undirected\">" << "\n";
myfile << "\t\t<edges>" << std::endl;
for (int i = 0; i < nodos.size(); i++) {
GetNodesAtHop(G, nodos[i], 1, conexiones, false);
for (int j = 0; j < conexiones.EndI() - conexiones.BegI(); j++) {
if (conexiones[j] > i) {
myfile << "\t\t\t<edge id=\"" << aristas << "\" source=\"" << i << "\" target=\"" << conexiones[j] << "\"/>" << "\n";
aristas++;
}
}
conexiones.Clr();
}
myfile << "\t\t</edges>" << "\n";
myfile << "\t</graph>" << "\n";
myfile << "</gexf>" << "\n";
myfile.close();
}//cierre de grafoGDF
void grafoML(PUNGraph G) {
std::ofstream myfile;
std::vector<int> nodos = obtenerVerticesOrdenados(G);
long int aristas = 1;
TIntV conexiones;
myfile.open("facebook.graphml");
myfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << "\n";
myfile << "<graphml xmlns=\"http://graphml.graphdrawing.org/xmlns\"" << "\n";
myfile << "\txmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"" << "\n";
myfile << "\txsi:schemaLocation=\"http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd\">" << "\n";
myfile << " <graph id=\"G\" edgedefault=\"undirected\">" << "\n";
for (int i = 0; i < nodos.size(); i++) {
GetNodesAtHop(G, nodos[i], 1, conexiones, false);
for (int j = 0; j < conexiones.EndI() - conexiones.BegI(); j++) {
if (conexiones[j] > i) {
myfile << " \t<edge id=\"e" << aristas << "\" source=\"" << i << "\" target=\"" << conexiones[j] << "\"/>" << "\n";
aristas++;
}
}
conexiones.Clr();
}
myfile << " </graph>" << "\n";
myfile << "</graphml>" << "\n";
myfile.close();
}//cierre de grafoGDF
PNEANet KNNJaccardParallel(PNGraph Graph,int K) {
PNEANet KNN = TNEANet::New();
TIntV NIdV;
Graph->GetNIdV (NIdV);
int size = NIdV.Len();
for (int ind = 0; ind < size; ind++) {
KNN->AddNode(NIdV[ind]);
}
KNN->AddFltAttrE("sim");
TVec<TVec<TPair<TFlt, TInt>, int >, int > TopKList;
TVec<TVec<TPair<TFlt, TInt>, int >, int > ThTopK; // for each thread
TIntV NodeList;
TIntV ThNodeList;// for each thread
int NumThreads = omp_get_max_threads();
omp_set_num_threads(NumThreads);
#pragma omp parallel private(ThNodeList, ThTopK)
{
TIntV* Neighbors_old = new TIntV();
TIntV* Neighbors = new TIntV();
TIntV* temp;
#pragma omp for schedule(dynamic,1000)
for (int ind = 0; ind < size; ind++) {
TNGraph::TNodeI NI = Graph->GetNI(NIdV[ind]);
if (NI.GetInDeg() > 0) {
continue;
}
if (NI.GetOutDeg() == 0) {
continue;
}
TVec<TPair<TFlt, TInt>, int > TopK;
for (int i = 0; i < K; i++) {
TopK.Add(TPair<TFlt,TInt>(0.0, -1));
}
Neighbors->Clr(false);
Neighbors_old->Clr(false);
for (int i = 0; i < NI.GetOutDeg(); i++) {
TNGraph::TNodeI Inst_NI = Graph->GetNI(NI.GetOutNId(i));
MergeNbrs(Neighbors, Neighbors_old, Inst_NI);
temp = Neighbors_old;
temp->Clr(false);
Neighbors_old = Neighbors;
Neighbors = temp;
}
// Swap neighbors and Neighbors_old
temp = Neighbors_old;
Neighbors_old = Neighbors;
Neighbors = temp;
for(int j = 0; j< Neighbors->Len(); j++) {
TNGraph::TNodeI Auth_NI = Graph->GetNI((*Neighbors)[j]);
float similarity = JaccardSim(NI, Auth_NI);
if (TopK[K-1].GetVal1() < similarity) {
int index = 0;
for (int i = K-2; i >= 0; i--)
if (TopK[i].GetVal1() < similarity) {
TopK.SetVal(i+1, TopK[i]);
} else {
index = i+1;
break;
}
TopK.SetVal(index, TPair<TFlt, TInt>(similarity, (*Neighbors)[j]));
}
}
ThTopK.Add(TopK);
ThNodeList.Add(NIdV[ind]);
// if (ct%10000 == 0)
// cout<<ct<<" avg neighbor degree = "<<sum_neighbors*1.0/ct<<" "<<currentDateTime()<<endl;
}
#pragma omp critical
{
for (int j = 0; j < ThTopK.Len(); j++) {
TopKList.Add(ThTopK[j]);
NodeList.Add(ThNodeList[j]);
}
}
}
int size2 = NodeList.Len();
for (int i= 0; i < size2 ; i++) {
for (int j = 0; j < K; j++) {
if (TopKList[i][j].GetVal2() <= -1) {
break;
}
int EId = KNN->AddEdge(NodeList[i], TopKList[i][j].GetVal2());
KNN->AddFltAttrDatE(EId, TopKList[i][j].GetVal1(), "sim");
}
}
return KNN;
}
PNEANet KNNJaccard(PNGraph Graph, int K) {
PNEANet KNN = TNEANet::New();
int sum_neighbors = 0;
int ct;
int end;
end = Graph->GetNodes();
TIntV* Neighbors_old = new TIntV();
TIntV* Neighbors = new TIntV();
TIntV* temp;
TIntV NIdV;
Graph->GetNIdV (NIdV);
int size = NIdV.Len();
for (int ind = 0; ind < size; ind++) {
KNN->AddNode(NIdV[ind]);
}
KNN->AddFltAttrE("sim");
for (int ind = 0; ind < size; ind++) {
TNGraph::TNodeI NI = Graph->GetNI(NIdV[ind]);
if (NI.GetInDeg() > 0) {
continue;
}
if (NI.GetOutDeg() == 0) {
continue;
}
ct ++;
TVec<TPair<TFlt, TInt> > TopK;
for (int i = 0; i < K; i++) {
TopK.Add(TPair<TFlt,TInt>(0.0, -1));
}
Neighbors->Clr(false);
Neighbors_old->Clr(false);
for (int i = 0; i < NI.GetOutDeg(); i++) {
TNGraph::TNodeI Inst_NI = Graph->GetNI(NI.GetOutNId(i));
MergeNbrs(Neighbors, Neighbors_old, Inst_NI);
temp = Neighbors_old;
temp->Clr(false);
Neighbors_old = Neighbors;
Neighbors = temp;
}
int num = Neighbors_old->Len();
sum_neighbors += num;
//Swap neighbors and Neighbors_old
temp = Neighbors_old;
Neighbors_old = Neighbors;
Neighbors = temp;
for (int j = 0; j< Neighbors->Len(); j++) {
TNGraph::TNodeI Auth_NI = Graph->GetNI((*Neighbors)[j]);
float similarity = JaccardSim(NI, Auth_NI);
if (TopK[K-1].GetVal1() < similarity) {
int index = 0;
for (int i = K-2; i >= 0; i--)
if (TopK[i].GetVal1() < similarity) {
TopK.SetVal(i+1, TopK[i]);
} else {
index = i+1;
break;
}
TopK.SetVal(index, TPair<TFlt, TInt>(similarity, (*Neighbors)[j]));
}
}
for (int i = 0; i < K; i++) {
int EId = KNN->AddEdge(NI.GetId(), TopK[i].GetVal2());
KNN->AddFltAttrDatE(EId, TopK[i].GetVal1(), "sim");
}
// if (ct%10000 == 0)
// cout<<ct<<" avg neighbor degree = "<<sum_neighbors*1.0/ct<<" "<<currentDateTime()<<endl;
}
return KNN;
}
// Node selects N~geometric(1.0-FwdBurnProb)-1 out-links and burns them. Then same for in-links.
// geometirc(p) has mean 1/(p), so for given FwdBurnProb, we burn 1/(1-FwdBurnProb)
void TForestFire::BurnGeoFire() {
const double OldFwdBurnProb = FwdBurnProb;
const double OldBckBurnProb = BckBurnProb;
const int& NInfect = InfectNIdV.Len();
const TNGraph& G = *Graph;
TIntH BurnedNIdH; // burned nodes
TIntV BurningNIdV = InfectNIdV; // currently burning nodes
TIntV NewBurnedNIdV; // nodes newly burned in current step
bool HasAliveInNbrs, HasAliveOutNbrs; // has unburned neighbors
TIntV AliveNIdV; // NIds of alive neighbors
int NBurned = NInfect, time;
for (int i = 0; i < InfectNIdV.Len(); i++) {
BurnedNIdH.AddDat(InfectNIdV[i]);
}
NBurnedTmV.Clr(false); NBurningTmV.Clr(false); NewBurnedTmV.Clr(false);
for (time = 0;; time++) {
NewBurnedNIdV.Clr(false);
for (int node = 0; node < BurningNIdV.Len(); node++) {
const int& BurningNId = BurningNIdV[node];
const TNGraph::TNodeI Node = G.GetNI(BurningNId);
// find unburned links
HasAliveOutNbrs = false;
AliveNIdV.Clr(false); // unburned links
for (int e = 0; e < Node.GetOutDeg(); e++) {
const int OutNId = Node.GetOutNId(e);
if (!BurnedNIdH.IsKey(OutNId)) {
HasAliveOutNbrs = true; AliveNIdV.Add(OutNId);
}
}
// number of links to burn (geometric coin). Can also burn 0 links
const int BurnNFwdLinks = Rnd.GetGeoDev(1.0 - FwdBurnProb) - 1;
if (HasAliveOutNbrs && BurnNFwdLinks > 0) {
AliveNIdV.Shuffle(Rnd);
for (int i = 0; i < TMath::Mn(BurnNFwdLinks, AliveNIdV.Len()); i++) {
BurnedNIdH.AddDat(AliveNIdV[i]);
NewBurnedNIdV.Add(AliveNIdV[i]); NBurned++;
}
}
// backward links
if (BckBurnProb > 0.0) {
// find unburned links
HasAliveInNbrs = false;
AliveNIdV.Clr(false);
for (int e = 0; e < Node.GetInDeg(); e++) {
const int InNId = Node.GetInNId(e);
if (!BurnedNIdH.IsKey(InNId)) {
HasAliveInNbrs = true; AliveNIdV.Add(InNId);
}
}
// number of links to burn (geometric coin). Can also burn 0 links
const int BurnNBckLinks = Rnd.GetGeoDev(1.0 - BckBurnProb) - 1;
if (HasAliveInNbrs && BurnNBckLinks > 0) {
AliveNIdV.Shuffle(Rnd);
for (int i = 0; i < TMath::Mn(BurnNBckLinks, AliveNIdV.Len()); i++) {
BurnedNIdH.AddDat(AliveNIdV[i]);
NewBurnedNIdV.Add(AliveNIdV[i]); NBurned++;
}
}
}
}
NBurnedTmV.Add(NBurned); NBurningTmV.Add(BurningNIdV.Len()); NewBurnedTmV.Add(NewBurnedNIdV.Len());
// BurningNIdV.AddV(NewBurnedNIdV); // node is burning eternally
BurningNIdV.Swap(NewBurnedNIdV); // node is burning just 1 time step
if (BurningNIdV.Empty()) break;
FwdBurnProb = FwdBurnProb * ProbDecay;
BckBurnProb = BckBurnProb * ProbDecay;
}
BurnedNIdV.Gen(BurnedNIdH.Len(), 0);
for (int i = 0; i < BurnedNIdH.Len(); i++) {
BurnedNIdV.Add(BurnedNIdH.GetKey(i));
}
FwdBurnProb = OldFwdBurnProb;
BckBurnProb = OldBckBurnProb;
}
