C++ TNodeI类代码示例

void TWgtNet::PutRnd01Wgts() {
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) {
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      NI.GetOutEDat(e) = TInt::Rnd.GetUniDev();
    }
  }
}

void TWgtNet::MulEdgeWgt(const double& MulBy) {
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) {
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      NI.GetOutEDat(e) *= MulBy;
    }
  }
}

// actors collaboration graph
PUNGraph TImdbNet::GetActorGraph() const  { 
  TIntPrSet EdgeSet;
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) {
    if (NI().GetTy() == mtyActor) {
      const int NId1 = NI.GetId();
      for (int e = 0; e < NI.GetOutDeg(); e++) {
        if (NI.GetOutNDat(e).GetTy() != mtyActor) {
          TNodeI NI2 = GetNI(NI.GetOutNId(e));
          for (int e2 = 0; e2 < NI2.GetInDeg(); e2++) {
            if (NI2.GetInNDat(e2).GetTy() == mtyActor) {
              const int NId2 = NI2.GetInNId(e2);
              EdgeSet.AddKey(TIntPr(TMath::Mn(NId1, NId2), TMath::Mx(NId1, NId2)));
            }
          }
        }
      }
    }
  }
  PUNGraph G = TUNGraph::New(); 
  for (int i = 0; i < EdgeSet.Len(); i++) {
    const int NId1 = EdgeSet[i].Val1;
    const int NId2 = EdgeSet[i].Val2;
    if (! G->IsNode(NId1)) { G->AddNode(NId1); }
    if (! G->IsNode(NId2)) { G->AddNode(NId2); }
    G->AddEdge(NId1, NId2);
  }
  return G;
}

/////////////////////////////////////////////////
// Weighted network
double TWgtNet::GetEdgeWgt() const {
  double wgt = 0;
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) {
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      wgt += NI.GetOutEDat(e);
    }
  }
  return wgt;
}

void TWgtNet::PermOutEdgeWgt() {
  TFltV WgtV;
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) {
    WgtV.Clr(false);
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      WgtV.Add(NI.GetOutEDat(e)); 
    }
    WgtV.Shuffle(TInt::Rnd);
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      NI.GetOutEDat(e) = WgtV[e]; 
    }
  }
}

int TMultimodalGraphImplB::BFSTraversalOneHop(const TVec< TPair<TInt,TInt> >& StartingVertices) const {
  int NumVerticesAndEdges = 0;
  for (int i = 0; i < StartingVertices.Len(); i++) {
    TNodeI NI = GetNI(StartingVertices.GetVal(i));
    TIntV AdjacentModes = TIntV(); NI.GetAdjacentModes(AdjacentModes);
    for (int ModeIdx = 0; ModeIdx < AdjacentModes.Len(); ModeIdx++) {
      int ModeId = AdjacentModes.GetVal(ModeIdx);
      for (int e = 0; e < NI.GetOutDeg(ModeId); e++) {
        NumVerticesAndEdges += NI.GetOutNId(e, ModeId);
      }
    }
  }
  return NumVerticesAndEdges;
}

void TWgtNet::DelMinWgtNodes(const double MinWgt) {
  printf("Deleting Min Wgt %g nodes\n", MinWgt);
  printf("  (%d,%d)  -->", GetNodes(), GetEdges());
  TIntV DelNIdV;  
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) {
    double wgt = 0;
    for (int e = 0; e < NI.GetOutDeg(); e++) { 
      wgt += NI.GetOutEDat(e);
    }
    if (wgt < MinWgt) { DelNIdV.Add(NI.GetId()); }
  }
  for (int d = 0; d < DelNIdV.Len(); d++) {
    DelNode(DelNIdV[d]);
  }
  printf("  (%d,%d)\n", GetNodes(), GetEdges());
}

TMultimodalGraphImplB::TEdgeI TMultimodalGraphImplB::GetEI(const TPair<TInt,TInt>& SrcNId, const TPair<TInt,TInt>& DstNId) const {
  TNodeI CurNode = TNodeI(NodeToModeMapping.GetI(SrcNId.GetVal2()), &Graphs, &NodeToModeMapping);
  TIntV AdjacentModes = TIntV();
  CurNode.GetAdjacentModes(AdjacentModes);

  TPair<TInt,TInt> ModeIdsKey = GetModeIdsKey(SrcNId.GetVal1(), DstNId.GetVal1());

  int CurAdjacentMode = 0;
  for (int i=0; i<AdjacentModes.Len();i++) {
    if (AdjacentModes.GetDat(i) == DstNId.GetVal1()) {
      CurAdjacentMode=i;
      break;
    }
  }

  return TEdgeI(CurNode, EndNI(), Graphs.GetDat(ModeIdsKey).GetEI(SrcNId.GetVal2(), DstNId.GetVal2()).GetCurEdge(), AdjacentModes, CurAdjacentMode);
}

// set actor's language and country
void TImdbNet::SetActorCntryLangByMajority() {
    // set language
  TIntPrV NIdToVal;
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) {
    if (! NI().IsActor()) { continue; }
    IAssert(NI().GetLang() == 0); // no language set
    IAssert(NI.GetInDeg() == 0);  // actors point to movies
    int Nbhs=0;  TIntH LangCntH;
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      LangCntH.AddDat(NI.GetOutNDat(e).GetLang()) += 1;  Nbhs++; }
    if (LangCntH.IsKey(0)) { Nbhs-=LangCntH.GetDat(0); LangCntH.GetDat(0)=0; }
    LangCntH.SortByDat(false);
    if (LangCntH.GetKey(0) == 0) { continue; }
    if (LangCntH[0]*2 >= Nbhs) { 
      NIdToVal.Add(TIntPr(NI.GetId(), LangCntH.GetKey(0))); }
  }
  for (int i = 0; i < NIdToVal.Len(); i++) {
    GetNDat(NIdToVal[i].Val1).Lang = NIdToVal[i].Val2; }
  printf("  language set: %d\n", NIdToVal.Len());
  
  int cnt=0;
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) { if (NI().IsActor() && NI().GetLang()==0) cnt++; }
  printf("  Actors NO language: %d\n\n", cnt);
  // set country
  NIdToVal.Clr(true);
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) {
    if (! NI().IsActor()) { continue; }
    IAssert(NI().GetCntry() == 0); // no country set
    IAssert(NI.GetInDeg() == 0);   // actors point to movies
    int Nbhs=0; TIntH CntryCntH;
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      CntryCntH.AddDat(NI.GetOutNDat(e).GetCntry()) += 1;  Nbhs++; }
    if (CntryCntH.IsKey(0)) { Nbhs-=CntryCntH.GetDat(0); CntryCntH.GetDat(0)=0; }
    CntryCntH.SortByDat(false);
    if (CntryCntH.GetKey(0) == 0) { continue; }
    if (CntryCntH[0]*2 >= Nbhs) { 
      NIdToVal.Add(TIntPr(NI.GetId(), CntryCntH.GetKey(0))); }
  }
  for (int i = 0; i < NIdToVal.Len(); i++) {
    GetNDat(NIdToVal[i].Val1).Cntry = NIdToVal[i].Val2; }
  printf("  country set: %d\n", NIdToVal.Len());
  cnt=0;
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) { if (NI().IsActor() && NI().GetCntry()==0) cnt++; }
  printf("  Actors NO country: %d\n\n", cnt);
}

TFlt TNEANetMP::GetWeightOutEdges(const TNodeI& NI, const TStr& attr) {
    TNode Node = GetNode(NI.GetId());
    TIntV OutEIdV = Node.OutEIdV;
    TFlt total = 0;
    int len = Node.OutEIdV.Len();
    for (int i = 0; i < len; i++) {
        total += GetFltAttrDatE(Node.OutEIdV[i], attr);
    }
    return total;
}

void TMultimodalGraphImplB::RandomWalk(TVec< TPair<TInt,TInt> > NodeIds, int WalkLength) {
  int CurrentLocalNodeId = NodeToModeMapping.GetKey(NodeToModeMapping.GetRndKeyId(TInt::Rnd));
  TPair<TInt,TInt> CurrentNodeId = TPair<TInt,TInt>(NodeToModeMapping.GetDat(CurrentLocalNodeId), CurrentLocalNodeId);
  int NodeIdIdx = 0;
  NodeIds.SetVal(NodeIdIdx++, CurrentNodeId);
  while (NodeIds.Len() < WalkLength) {
    TNodeI NI = GetNI(CurrentNodeId);
    TIntV AdjacentModes = TIntV(); NI.GetAdjacentModes(AdjacentModes);
    // Throw an appropriately biased coin here
    int EdgeId = TInt::Rnd.GetUniDevInt(NI.GetOutDeg());
    int i;
    for (i = 0; i < AdjacentModes.Len(); i++) {
      int ModeOutDeg = NI.GetOutDeg(AdjacentModes.GetDat(i));
      if (EdgeId < ModeOutDeg) { break; }
      EdgeId -= ModeOutDeg;
    }
    NodeIds.SetVal(NodeIdIdx++, TPair<TInt,TInt>(AdjacentModes.GetDat(i), NI.GetOutNId(EdgeId, AdjacentModes.GetDat(i))));
  }
}

void TNEGraph::Dump(FILE *OutF) const {
  const int NodePlaces = (int) ceil(log10((double) GetNodes()));
  const int EdgePlaces = (int) ceil(log10((double) GetEdges()));
  fprintf(OutF, "-------------------------------------------------\nDirected Node-Edge Graph: nodes: %d, edges: %d\n", GetNodes(), GetEdges());
  for (TNodeI NodeI = BegNI(); NodeI < EndNI(); NodeI++) {
    fprintf(OutF, "  %*d]\n", NodePlaces, NodeI.GetId());
    fprintf(OutF, "    in[%d]", NodeI.GetInDeg());
    for (int edge = 0; edge < NodeI.GetInDeg(); edge++) {
      fprintf(OutF, " %*d", EdgePlaces, NodeI.GetInEId(edge)); }
    fprintf(OutF, "\n    out[%d]", NodeI.GetOutDeg());
    for (int edge = 0; edge < NodeI.GetOutDeg(); edge++) {
      fprintf(OutF, " %*d", EdgePlaces, NodeI.GetOutEId(edge)); }
    fprintf(OutF, "\n");
  }
  for (TEdgeI EdgeI = BegEI(); EdgeI < EndEI(); EdgeI++) {
    fprintf(OutF, "  %*d]  %*d  ->  %*d\n", EdgePlaces, EdgeI.GetId(), NodePlaces, EdgeI.GetSrcNId(), NodePlaces, EdgeI.GetDstNId());
  }
  fprintf(OutF, "\n");
}

void TWgtNet::PermEdgeWgt() {
  TFltV WgtV;
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) {
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      WgtV.Add(NI.GetOutEDat(e)); 
    }
  }
  WgtV.Shuffle(TInt::Rnd);
  int w = 0;
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) {
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      NI.GetOutEDat(e) = WgtV[w++]; 
    }
  }
}

// Wgt == -1 : take the weight of the edge in the opposite direction
void TWgtNet::AddBiDirEdges(const double& Wgt) {
  TIntPrV EdgeV;
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) {
    for (int e = 0; e < NI.GetOutDeg(); e++) { 
      if (! IsEdge(NI.GetOutNId(e), NI.GetId())) {
        EdgeV.Add(TIntPr(NI.GetOutNId(e), NI.GetId())); }
    }
  }
  for (int e = 0; e < EdgeV.Len(); e++) {
    if (Wgt != -1) {
      AddEdge(EdgeV[e].Val1, EdgeV[e].Val2, Wgt);
    } else { // edge weight in the opposite direction
      AddEdge(EdgeV[e].Val1, EdgeV[e].Val2, GetEDat(EdgeV[e].Val2, EdgeV[e].Val1));
    }
  }
}

PMultimodalGraphImplC TMultimodalGraphImplB::ConvertToImplC() const {
  PMultimodalGraphImplC G = TMultimodalGraphImplC::New();
  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) {
    G->AddNode(TPair<TInt,TInt>(NI.GetModeId(), NI.GetId()));
  }

  for (TNodeI NI = BegNI(); NI < EndNI(); NI++) {
    int OutDeg = NI.GetOutDeg();
    int InDeg = NI.GetInDeg();
    G->ReserveInAndOutNIdV(TPair<TInt,TInt>(NI.GetModeId(), NI.GetId()), OutDeg, InDeg);
    TVec<TInt> AdjacentModes = TVec<TInt>(); NI.GetAdjacentModes(AdjacentModes);
    for (int i = 0; i < AdjacentModes.Len(); i++) {
      int AdjacentMode = AdjacentModes.GetVal(i);
      TPair<TInt,TInt> ModeIdsKey = GetModeIdsKey(NI.GetModeId(), AdjacentMode);
      G->AddOutNIds(TPair<TInt,TInt>(NI.GetModeId(),NI.GetId()), Graphs.GetDat(ModeIdsKey).GetOutNId(NI.GetId()), AdjacentMode);
      G->AddInNIds(TPair<TInt,TInt>(NI.GetModeId(),NI.GetId()), Graphs.GetDat(ModeIdsKey).GetInNId(NI.GetId()), AdjacentMode);
    }
  }
  return G;
}