SNAP Library 2.1, User Reference  2013-09-25 10:47:25
SNAP, a general purpose, high performance system for analysis and manipulation of large networks
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Public Member Functions | Static Public Member Functions | Public Attributes
TNetConstraint< PGraph > Class Template Reference

#include <triad.h>

List of all members.

Public Member Functions

 TNetConstraint (const PGraph &GraphPt, const bool &CalcaAll=true)
int Len () const
double GetC (const int &ConstraintN) const
TIntPr GetNodePr (const int &ConstraintN) const
double GetEdgeC (const int &NId1, const int &NId2) const
double GetNodeC (const int &NId) const
void AddConstraint (const int &NId1, const int &NId2)
void CalcConstraints ()
void CalcConstraints (const int &NId)
void Dump () const

Static Public Member Functions

static void Test ()

Public Attributes

PGraph Graph
THash< TIntPr, TFlt > NodePrCH

Detailed Description

template<class PGraph>
class TNetConstraint< PGraph >

Definition at line 452 of file triad.h.

Constructor & Destructor Documentation

template<class PGraph >
TNetConstraint< PGraph >::TNetConstraint ( const PGraph &  GraphPt,
const bool &  CalcaAll = true 
)

Definition at line 471 of file triad.h.

                                                                                  : Graph(GraphPt) {
  CAssert(! HasGraphFlag(typename PGraph::TObj, gfMultiGraph)); // must not be multigraph
  if (CalcaAll) {
    CalcConstraints();
  }
}

Member Function Documentation

template<class PGraph >
void TNetConstraint< PGraph >::AddConstraint ( const int &  NId1,
const int &  NId2 
)

Definition at line 507 of file triad.h.

                                                                           {
  if (NId1==NId2 || NodePrCH.IsKey(TIntPr(NId1, NId2))) {
    return;
  }
  typename PGraph::TObj::TNodeI NI1 = Graph->GetNI(NId1);
  double Constraint = 0.0;
  if (NI1.IsOutNId(NId2)) { // is direct edge
    Constraint += 1.0/(double) NI1.GetOutDeg();
  }
  const double SrcC = 1.0/(double) NI1.GetOutDeg();
  for (int e = 0; e < NI1.GetOutDeg(); e++) {
    const int MidNId = NI1.GetOutNId(e);
    if (MidNId == NId1 || MidNId == NId2) { continue; }
    const typename PGraph::TObj::TNodeI MidNI = Graph->GetNI(MidNId);
    if (MidNI.IsOutNId(NId2)) {
      Constraint += SrcC * (1.0/(double)MidNI.GetOutDeg());
    }
  }
  if (Constraint==0) { return; }
  Constraint = TMath::Sqr(Constraint);
  NodePrCH.AddDat(TIntPr(NId1, NId2), Constraint);
}
template<class PGraph >
void TNetConstraint< PGraph >::CalcConstraints ( )

Definition at line 531 of file triad.h.

                                             {
  // add edges
  for (typename PGraph::TObj::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
    AddConstraint(EI.GetSrcNId(), EI.GetDstNId());
    AddConstraint(EI.GetDstNId(), EI.GetSrcNId());
  }
  // add open triads
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    for (int i = 0; i < NI.GetDeg();  i++) {
      const int NId1 = NI.GetNbrNId(i);
      for (int j = 0; j < NI.GetDeg();  j++) {
        const int NId2 = NI.GetNbrNId(j);
        AddConstraint(NId1, NId2);
      }
    }
  }
  NodePrCH.SortByKey();
}
template<class PGraph >
void TNetConstraint< PGraph >::CalcConstraints ( const int &  NId)

Definition at line 552 of file triad.h.

                                                           {
  typename PGraph::TObj::TNodeI StartNI = Graph->GetNI(NId);
  TIntSet SeenSet;
  for (int e = 0; e < StartNI.GetOutDeg(); e++) {
    typename PGraph::TObj::TNodeI MidNI = Graph->GetNI(StartNI.GetOutNId(e));
    AddConstraint(NId, MidNI.GetId());
    for (int i = 0; i < MidNI.GetOutDeg();  i++) {
      const int EndNId = MidNI.GetOutNId(i);
      if (! SeenSet.IsKey(EndNId)) {
        AddConstraint(NId, EndNId);
        SeenSet.AddKey(EndNId);
      }
    }
  }
}
template<class PGraph >
void TNetConstraint< PGraph >::Dump ( ) const

Definition at line 569 of file triad.h.

                                        {
  printf("Edge network constraint: (%d, %d)\n", Graph->GetNodes(), Graph->GetEdges());
  for (int e = 0; e < NodePrCH.Len(); e++) {
    printf("  %4d %4d  :  %f\n", NodePrCH.GetKey(e).Val1(), NodePrCH.GetKey(e).Val2(), NodePrCH[e].Val);
  }
  printf("\n");
}
template<class PGraph>
double TNetConstraint< PGraph >::GetC ( const int &  ConstraintN) const [inline]

Definition at line 459 of file triad.h.

{ return NodePrCH[ConstraintN]; }
template<class PGraph >
double TNetConstraint< PGraph >::GetEdgeC ( const int &  NId1,
const int &  NId2 
) const

Definition at line 479 of file triad.h.

                                                                              {
  if (NodePrCH.IsKey(TIntPr(NId1, NId2))) {
    return NodePrCH.GetDat(TIntPr(NId1, NId2)); }
  else {
    return 0.0; }
}
template<class PGraph >
double TNetConstraint< PGraph >::GetNodeC ( const int &  NId) const

Definition at line 487 of file triad.h.

                                                            {
  typename PGraph::TObj::TNodeI NI1 = Graph->GetNI(NId);
  if (NI1.GetOutDeg() == 0) { return 0.0; }
  int KeyId = -1;
  for (int k = 0; k<NI1.GetOutDeg(); k++) {
    KeyId = NodePrCH.GetKeyId(TIntPr(NI1.GetId(), NI1.GetOutNId(k)));
    if (KeyId > -1) { break; }
  }
  if (KeyId < 0) { return 0.0; }
  double Constraint = NodePrCH[KeyId];
  for (int i = KeyId-1; i >-1 && NodePrCH.GetKey(i).Val1()==NId; i--) {
    Constraint += NodePrCH[i];
  }
  for (int i = KeyId+1; i < NodePrCH.Len() && NodePrCH.GetKey(i).Val1()==NId; i++) {
    Constraint += NodePrCH[i];
  }
  return Constraint;
}
template<class PGraph>
TIntPr TNetConstraint< PGraph >::GetNodePr ( const int &  ConstraintN) const [inline]

Definition at line 460 of file triad.h.

{ return NodePrCH.GetKey(ConstraintN); }
template<class PGraph>
int TNetConstraint< PGraph >::Len ( ) const [inline]

Definition at line 458 of file triad.h.

{ return NodePrCH.Len(); }
template<class PGraph >
void TNetConstraint< PGraph >::Test ( ) [static]

Definition at line 580 of file triad.h.

                                  {
  PUNGraph G = TUNGraph::New();
  G->AddNode(0); G->AddNode(1); G->AddNode(2); G->AddNode(3);
  G->AddNode(4); G->AddNode(5); G->AddNode(6);
  G->AddEdge(0,1); G->AddEdge(0,2); G->AddEdge(0,3); G->AddEdge(0,4); G->AddEdge(0,5); G->AddEdge(0,6);
  G->AddEdge(1,2); G->AddEdge(1,5);  G->AddEdge(1,6);
  G->AddEdge(2,4);
  TNetConstraint<PUNGraph> NetConstraint(G, true);
  // NetConstraint.CalcConstraints(0);
  NetConstraint.Dump();
  printf("middle node network constraint: %f\n", NetConstraint.GetNodeC(0));
}

Member Data Documentation

template<class PGraph>
PGraph TNetConstraint< PGraph >::Graph

Definition at line 454 of file triad.h.

template<class PGraph>
THash<TIntPr, TFlt> TNetConstraint< PGraph >::NodePrCH

Definition at line 455 of file triad.h.

The documentation for this class was generated from the following file: