#include <timenet.h>

Inherits TNodeNet< TSecTm >.

Classes
class	TTmBucket

Public Types
typedef TNodeNet< TSecTm >	TNet

typedef TPt< TNodeNet< TSecTm > >	PNet

typedef TVec< TTmBucket >	TTmBucketV

Public Types inherited from TNodeNet< TSecTm >
typedef TSecTm	TNodeDat

typedef TNodeNet< TSecTm >	TNet

typedef TPt< TNet >	PNet

Public Member Functions
	TTimeNet ()

	TTimeNet (const int &Nodes, const int &Edges)

	TTimeNet (const TTimeNet &TimeNet)

	TTimeNet (TSIn &SIn)

void	Save (TSOut &SOut) const
	Saves the network to a (binary) stream SOut. More...

TTimeNet &	operator= (const TTimeNet &TimeNet)

PTimeNet	GetSubGraph (const TIntV &NIdV) const

PTimeNENet	GetTimeNENet () const

void	GetNIdByTm (TIntV &NIdV) const

void	GetTmBuckets (const TTmUnit &GroupBy, TTmBucketV &TmBucketV) const

void	GetNodeBuckets (const int NodesPerBucket, TTimeNet::TTmBucketV &TmBucketV) const

PGStatVec	TimeGrowth (const TTmUnit &TmUnit, const TFSet &TakeStat, const TSecTm &StartTm) const

void	PlotEffDiam (const TStr &FNmPref, const TStr &Desc, const TTmUnit &GroupBy, const TSecTm &StartTm, const int &NDiamRuns=10, const bool &OnlyWcc=false, const bool &AlsoRewire=false) const

void	PlotMissingPast (const TStr &FNmPref, const TStr &Desc, const TTmUnit &GroupBy, const TSecTm &DelPreTmEdges, const TSecTm &PostTmDiam) const

void	PlotCCfOverTm (const TStr &FNmPref, TStr Desc, const TTmUnit &TmUnit, const int &NodesBucket=-1) const

void	PlotMedianDegOverTm (const TStr &FNmPref, const TTmUnit &TmUnit, const int &NodesPerBucket=-1) const

Public Member Functions inherited from TNodeNet< TSecTm >
const TNode &	GetNode (const int &NId) const
	Returns node element for the node of ID NId in the network. More...

	TNodeNet ()

	TNodeNet (const int &Nodes, const int &Edges)
	Constructor that reserves enough memory for a network of Nodes nodes and Edges edges. More...

	TNodeNet (const TNodeNet &NodeNet)

	TNodeNet (TSIn &SIn)
	Constructor that loads the network from a (binary) stream SIn. More...

virtual	~TNodeNet ()

bool	HasFlag (const TGraphFlag &Flag) const
	Allows for run-time checking the type of the network (see the TGraphFlag for flags). More...

TNodeNet &	operator= (const TNodeNet &NodeNet)

int	GetNodes () const
	Returns the number of nodes in the network. More...

int	AddNode (int NId=-1)
	Adds a node of ID NId to the network. More...

int	AddNode (int NId, const TSecTm &NodeDat)
	Adds a node of ID NId and node data NodeDat to the network. More...

int	AddNode (const TNodeI &NodeI)
	Adds a node NodeI and its node data to the network. More...

int	AddNodeUnchecked (int NId=-1)
	Adds a node of ID NId to the network, noop if the node already exists. More...

virtual void	DelNode (const int &NId)
	Deletes node of ID NId from the network. More...

void	DelNode (const TNode &NodeI)
	Deletes node of ID NodeI.GetId() from the network. More...

bool	IsNode (const int &NId) const
	Tests whether ID NId is a node. More...

TNodeI	BegNI () const
	Returns an iterator referring to the first node in the network. More...

TNodeI	EndNI () const
	Returns an iterator referring to the past-the-end node in the network. More...

TNodeI	GetNI (const int &NId) const
	Returns an iterator referring to the node of ID NId in the network. More...

void	SetNDat (const int &NId, const TSecTm &NodeDat)
	Sets node data for the node of ID NId in the network. More...

TSecTm &	GetNDat (const int &NId)
	Returns node data for the node of ID NId in the network. More...

const TSecTm &	GetNDat (const int &NId) const
	Returns node data for the node of ID NId in the network. More...

int	GetMxNId () const
	Returns an ID that is larger than any node ID in the network. More...

int	GetEdges () const
	Returns the number of edges in the network. More...

int	AddEdge (const int &SrcNId, const int &DstNId)
	Adds an edge from node SrcNId to node DstNId to the network. More...

int	AddEdge (const TEdgeI &EdgeI)
	Adds an edge from EdgeI.GetSrcNId() to EdgeI.GetDstNId() to the network. More...

void	DelEdge (const int &SrcNId, const int &DstNId, const bool &IsDir=true)
	Deletes an edge from node IDs SrcNId to DstNId from the network. More...

bool	IsEdge (const int &SrcNId, const int &DstNId, const bool &IsDir=true) const
	Tests whether an edge from node IDs SrcNId to DstNId exists in the network. More...

TEdgeI	BegEI () const
	Returns an iterator referring to the first edge in the network. More...

TEdgeI	EndEI () const
	Returns an iterator referring to the past-the-end edge in the network. More...

TEdgeI	GetEI (const int &EId) const
	Not supported/implemented! More...

TEdgeI	GetEI (const int &SrcNId, const int &DstNId) const
	Returns an iterator referring to edge (SrcNId, DstNId) in the network. More...

int	GetRndNId (TRnd &Rnd=TInt::Rnd)
	Returns an ID of a random node in the network. More...

TNodeI	GetRndNI (TRnd &Rnd=TInt::Rnd)
	Returns an interator referring to a random node in the network. More...

void	GetNIdV (TIntV &NIdV) const
	Gets a vector IDs of all nodes in the network. More...

bool	Empty () const
	Tests whether the network is empty (has zero nodes). More...

void	Clr (const bool &DoDel=true, const bool &ResetDat=true)
	Deletes all nodes and edges from the network. More...

void	Reserve (const int &Nodes, const int &Edges)
	Reserves memory for a network of Nodes nodes and Edges edges. More...

void	SortNIdById (const bool &Asc=true)
	Sorts nodes by node IDs. More...

void	SortNIdByDat (const bool &Asc=true)
	Sorts nodes by node data. More...

void	Defrag (const bool &OnlyNodeLinks=false)
	Defragments the network. More...

bool	IsOk (const bool &ThrowExcept=true) const
	Checks the network data structure for internal consistency. More...

Static Public Member Functions
static PTimeNet	New ()

static PTimeNet	New (const int &Nodes, const int &Edges)

static PTimeNet	Load (TSIn &SIn)

static PTimeNet	LoadBipartite (const TStr &InFNm)

static PTimeNet	LoadArxiv (const TStr &PaperFNm, const TStr &CiteFNm)

static PTimeNet	LoadPatents (const TStr &PatentFNm, const TStr &CiteFNm)

static PTimeNet	LoadAmazon (const TStr &StlFNm)

Static Public Member Functions inherited from TNodeNet< TSecTm >
static PNet	New ()
	Static constructor that returns a pointer to the network. Call: TPt <TNodeNet<TNodeData> > Net = TNodeNet<TNodeData>::New(). More...

static PNet	Load (TSIn &SIn)
	Static constructor that loads the network from a stream SIn and returns a pointer to it. More...

static PNet	LoadShM (TShMIn &ShMIn)
	Static constructor that loads the network from shared memory. More...

Friends
class	TPt< TTimeNet >

Additional Inherited Members
Protected Member Functions inherited from TNodeNet< TSecTm >
TNode &	GetNode (const int &NId)

Protected Attributes inherited from TNodeNet< TSecTm >
TCRef	CRef

TInt	MxNId

THash< TInt, TNode >	NodeH

Detailed Description

Definition at line 16 of file timenet.h.

Member Typedef Documentation

typedef TPt<TNodeNet<TSecTm> > TTimeNet::PNet

Definition at line 19 of file timenet.h.

typedef TNodeNet<TSecTm> TTimeNet::TNet

Definition at line 18 of file timenet.h.

typedef TVec<TTmBucket> TTimeNet::TTmBucketV

Definition at line 32 of file timenet.h.

Constructor & Destructor Documentation

TTimeNet::TTimeNet ( )

inline

Definition at line 34 of file timenet.h.

34 { }

TTimeNet::TTimeNet	(	const int &	Nodes,
		const int &	Edges
	)

inline

Definition at line 35 of file timenet.h.

35 : TNet(Nodes, Edges) { }

TTimeNet::TNet

TNodeNet< TSecTm > TNet

Definition: timenet.h:18

TTimeNet::TTimeNet ( const TTimeNet & TimeNet )

inline

Definition at line 36 of file timenet.h.

36 : TNet(TimeNet) { }

TTimeNet::TNet

TNodeNet< TSecTm > TNet

Definition: timenet.h:18

TTimeNet::TTimeNet ( TSIn & SIn )

inline

Definition at line 37 of file timenet.h.

37 : TNet(SIn) { }

TTimeNet::TNet

TNodeNet< TSecTm > TNet

Definition: timenet.h:18

Member Function Documentation

void TTimeNet::GetNIdByTm ( TIntV & NIdV ) const

Definition at line 48 of file timenet.cpp.

                                            {
   TVec<TKeyDat<TSecTm, TInt> > TmToNIdV(GetNodes(), 0);
   for (TNodeI NodeI = BegNI(); NodeI < EndNI(); NodeI++) {
     TmToNIdV.Add(TKeyDat<TSecTm, TInt>(NodeI.GetDat(), NodeI.GetId())); }
   TmToNIdV.Sort();
   NIdV.Gen(GetNodes(), 0);
   for (int i = 0; i < TmToNIdV.Len(); i++) {
     NIdV.Add(TmToNIdV[i].Dat); }
 }

void TTimeNet::GetNodeBuckets	(	const int	NodesPerBucket,
		TTimeNet::TTmBucketV &	TmBucketV
	)		const

Definition at line 77 of file timenet.cpp.

                                                                                            {
   TIntV NIdV;
   GetNIdByTm(NIdV);
   TmBucketV.Gen(NIdV.Len() / NodesPerBucket + 1, 0);
   for (int i = 0; i < NIdV.Len(); i++) {
     const int b = i/NodesPerBucket;
     if (TmBucketV.Len() <= b) { TmBucketV.Add(TTimeNet::TTmBucket(TSecTm(b))); }
     TmBucketV[b].NIdV.Add(NIdV[i]);
   }
 }

PTimeNet TTimeNet::GetSubGraph ( const TIntV & NIdV ) const

Definition at line 10 of file timenet.cpp.

                                                       {
   PTimeNet NewNetPt = TTimeNet::New();
   TTimeNet& NewNet = *NewNetPt;
   NewNet.Reserve(NIdV.Len(), -1);
   int node, edge;
   TNodeI NI;
   for (node = 0; node < NIdV.Len(); node++) {
     NewNet.AddNode(NIdV[node], GetNDat(NIdV[node])); // also copy the node data
   }
   for (node = 0; node < NIdV.Len(); node++) {
     NI = GetNI(NIdV[node]);
     const int SrcNId = NI.GetId();
     for (edge = 0; edge < NI.GetOutDeg(); edge++) {
       const int OutNId = NI.GetOutNId(edge);
       if (NewNet.IsNode(OutNId)) {
         NewNet.AddEdge(SrcNId, OutNId); }
     }
   }
   NewNet.Defrag();
   return NewNetPt;
 }

PTimeNENet TTimeNet::GetTimeNENet ( ) const

Definition at line 32 of file timenet.cpp.

                                         {
   TIntV NIdV;  GetNIdByTm(NIdV);
   PTimeNENet OutNet = TTimeNENet::New(GetNodes(), GetEdges());
   for (int i = 0; i < NIdV.Len(); i++) {
     const int Src = NIdV[i];
     const TTimeNet::TNodeI NI = GetNI(Src);
     const TSecTm SrcTm = NI.GetDat();
     if (! OutNet->IsNode(Src)) { OutNet->AddNode(Src, SrcTm); }
     for (int e = 0; e < NI.GetOutDeg(); e++) {
       if (! OutNet->IsNode(NI.GetOutNId(e))) { OutNet->AddNode(NI.GetOutNId(e), SrcTm); }
       OutNet->AddEdge(Src, NI.GetOutNId(e), -1, SrcTm);
     }
   }
   return OutNet;
 }

void TTimeNet::GetTmBuckets	(	const TTmUnit &	GroupBy,
		TTmBucketV &	TmBucketV
	)		const

Definition at line 59 of file timenet.cpp.

                                                                               {
   THash<TInt, TIntV> TmIdToNIdVH;
   for (TNodeI NodeI = BegNI(); NodeI < EndNI(); NodeI++) {
     const int TmId = NodeI().Round(TmUnit);
     if (! TmIdToNIdVH.IsKey(TmId)) TmIdToNIdVH.AddKey(TmId);
     TmIdToNIdVH.GetDat(TmId).Add(NodeI.GetId());
   }
   TVec<TPair<TInt, TIntV> > TmIdNIdVV;
   TmIdToNIdVH.GetKeyDatPrV(TmIdNIdVV);
   TmIdNIdVV.Sort();
   TmBucketV.Gen(TmIdNIdVV.Len());
   for (int i = 0; i < TmIdNIdVV.Len(); i++) {
     TTmBucket& Bucket = TmBucketV[i];
     Bucket.BegTm = TmIdNIdVV[i].Val1;
     Bucket.NIdV = TmIdNIdVV[i].Val2;
   }
 }

static PTimeNet TTimeNet::Load ( TSIn & SIn )

inlinestatic

Definition at line 41 of file timenet.h.

41 { return new TTimeNet(SIn); }

TTimeNet::TTimeNet

TTimeNet()

Definition: timenet.h:34

PTimeNet TTimeNet::LoadAmazon ( const TStr & StlFNm )

static

Definition at line 563 of file timenet.cpp.

                                                 {
   PTimeNet TimeNetPt = TTimeNet::New();
   TTimeNet& TimeNet = *TimeNetPt;
   TimeNet.Reserve(3953993, -1);
   printf("Amazon Share-the-Love...\n");
   char line [2024], MonthStr[4];
   int NLines=0;
   TStrV ColV;
   FILE *F = fopen(StlFNm.CStr(), "rt");
   while (! feof(F)) {
     memset(line, 0, 2024);
     fgets(line, 2024, F);
     if (strlen(line) == 0) break;
     TStr(line).SplitOnAllCh(',', ColV);
     const int SrcNId = ColV[0].GetInt();
     const int DstNId = ColV[1].GetInt();
     // time data
     TStr TmStr = ColV[2]; // time-format: 29JAN02:21:55:23
     int Year = TmStr.GetSubStr(5, 6).GetInt();
     if (Year < 10) { Year += 2000; } else { Year += 1900; }
     MonthStr[0]=toupper(TmStr[2]);  MonthStr[1]=tolower(TmStr[3]);
     MonthStr[2]=tolower(TmStr[4]);  MonthStr[3]=0;
     const int Month = TTmInfo::GetMonthN(MonthStr, lUs);
     const int Day = TmStr.GetSubStr(0, 1).GetInt();
     const int Hour = TmStr.GetSubStr(8, 9).GetInt();
     const int Min = TmStr.GetSubStr(11, 12).GetInt();
     const int Sec = TmStr.GetSubStr(14, 15).GetInt();
     // add nodes and links
     if (! TimeNet.IsNode(SrcNId)) { TimeNet.AddNode(SrcNId, TSecTm(Year, Month, Day, Hour, Min, Sec)); }
     if (! TimeNet.IsNode(DstNId)) { TimeNet.AddNode(DstNId, TSecTm(Year, Month, Day, Hour, Min, Sec)); }
     if (! TimeNet.IsEdge(SrcNId, DstNId)) { TimeNet.AddEdge(SrcNId, DstNId); }
     if (++NLines % 100000 == 0) printf("\r  %dk", NLines/1000);
   }
   fclose(F);
   printf("\r  %d lines read\n", NLines);
   printf("Graph: nodes: %d  edges: %d\n", TimeNet.GetNodes(), TimeNet.GetEdges());
   TimeNet.Defrag(true);
   return TimeNetPt;
 }

PTimeNet TTimeNet::LoadArxiv	(	const TStr &	PaperFNm,
		const TStr &	CiteFNm
	)

static

Definition at line 383 of file timenet.cpp.

                                                                       {
   TExeTm ExeTm;
   PTimeNet TimeNetPt = TTimeNet::New();
   TTimeNet& TimeNet = *TimeNetPt;
   printf("Arxiv citation graph (paper publication year)...\n");
   // load time data (file hep-ph-slacdates)
   char Line [1024];
   FILE *PprF = fopen(PaperFNm.CStr(), "rt");
   TStr StrId, StrTime;
   TStrV StrV, StrTimeV;
   int N = 0, DuplicateNode = 0;
   while (! feof(PprF)) {
     Line[0] = 0;
     fgets(Line, 1024, PprF);
     if (strlen(Line) == 0 || Line[0] == '#') continue;
     Line[strlen(Line)-1] = 0; // delete trailing '\n'
     TStr(Line).SplitOnWs(StrV);  IAssert(StrV.Len() == 2);
     StrId = StrV[0];  StrTime = StrV[1];  IAssert(!StrId.Empty() && !StrTime.Empty());
     StrTime.SplitOnAllCh('-', StrTimeV);  IAssert(StrTimeV.Len() == 3);
     const int NodeId = StrId.GetInt();
     if (! TimeNet.IsNode(NodeId)) {
       const int Year = StrTimeV[0].GetInt();
       const int Month = StrTimeV[1].GetInt();
       const int Day = StrTimeV[2].GetInt();
       TimeNet.AddNode(NodeId, TSecTm(Year, Month, Day));
     } else { DuplicateNode++; }
     if (++N % 10000 == 0) printf("\r  %dk", N/1000);
   }
   printf("\r  %d nodes read. %d duplicate nodes. %s\n", N, DuplicateNode, ExeTm.GetTmStr());
   fclose(PprF);
   // load citations (file hep-ph-citations)
   int NewSrcIds=0, NewDstIds=0, DupLinks=0, NewCits=0;
   FILE *CiteF = fopen(CiteFNm.CStr(), "rt");
   N = 0;  ExeTm.Tick();
   printf("Loading Arxiv citations...\n");
   TIntPrV EdgeV;
   THash<TInt, TSecTm> NIdToTimeH;
   while (! feof(CiteF)) {
     Line[0] = 0;
     fgets(Line, 1024, CiteF);
     if (strlen(Line) == 0 || Line[0] == '#') continue;
     Line[strlen(Line)-1] = 0; // delete trailing '\n'
     TStr(Line).SplitOnWs(StrV);  IAssert(StrV.Len() == 2);
     const int SrcNId = StrV[0].GetInt();
     const int DstNId = StrV[1].GetInt();
     EdgeV.Add(TIntPr(SrcNId, DstNId));
     // infer time of destination node -- earliest paper that cites the node (paper)
     if (! TimeNet.IsNode(DstNId) && TimeNet.IsNode(SrcNId)) {
       const TSecTm& SrcTm = TimeNet.GetNDat(SrcNId);
       if (! NIdToTimeH.IsKey(DstNId)) {
         NIdToTimeH.AddDat(DstNId, SrcTm);
         NewDstIds++;
       }
       else if (NIdToTimeH.GetDat(DstNId) < SrcTm) {
         NIdToTimeH.GetDat(DstNId) = SrcTm; }
     }
     if (++N % 10000 == 0) printf("\r  %dk", N/1000);
   }
   fclose(CiteF);
   // add infeered time nodes (nodes which are cited by papers with known time)
   for (int i = 0; i < NIdToTimeH.Len(); i++) {
     TimeNet.AddNode(NIdToTimeH.GetKey(i), NIdToTimeH[i]);
   }
   // add links
   for (int i = 0; i < EdgeV.Len(); i++) {
     const int SrcNId = EdgeV[i].Val1;
     const int DstNId = EdgeV[i].Val2;
     if (TimeNet.IsNode(SrcNId) && TimeNet.IsNode(DstNId)) {
       if (! TimeNet.IsEdge(SrcNId, DstNId)) { TimeNet.AddEdge(SrcNId, DstNId); }
       else { DupLinks++; }
     } else {
       if (! TimeNet.IsNode(SrcNId)) {
         NewSrcIds++;
         if (! TimeNet.IsNode(DstNId)) { NewCits++; }
       }
     }
   }
   printf("\r  %d citations read. %s\n", N, ExeTm.GetTmStr());
   printf("Graph: nodes: %d    edges: %d\n", TimeNet.GetNodes(), TimeNet.GetEdges());
   printf("Removing 0-degree nodes: %d nodes\n", TSnap::CntDegNodes(TimeNetPt, 0));
   TIntV RmNIdV;
   for (TTimeNet::TNodeI ni = TimeNet.BegNI(); ni < TimeNet.EndNI(); ni++) {
     if (ni.GetDeg() == 0) { RmNIdV.Add(ni.GetId()); }
   }
   for (int i = 0; i < RmNIdV.Len(); i++) {
     TimeNet.DelNode(RmNIdV[i]);
   }
   TimeNet.Defrag(true);
   printf("\nFinal graph: nodes: %d    edges: %d\n", TimeNet.GetNodes(), TimeNet.GetEdges());
   printf("  Duplicate citations                    : %d\n", DupLinks);
   printf("  Nodes without time which are cited     : %d (add them to graph, use time of the earliest source node)\n", NewDstIds);
   printf("  Citations between unknown time nodes   : %d\n", NewCits);
   printf("  Nodes without time which make citations: %d (do not add them into the graph)\n", NewSrcIds);
   return TimeNetPt;
 }

PTimeNet TTimeNet::LoadBipartite ( const TStr & InFNm )

static

Definition at line 346 of file timenet.cpp.

                                                   {
   PTimeNet TimeNetPt = TTimeNet::New();
   TTimeNet& TimeNet = *TimeNetPt;
   PSs Ss = TSs::LoadTxt(ssfTabSep, InFNm.CStr());
   TIntH Set1IdH; // paper ids
   TStrV StrTimeV;
   for (int y = 0; y < Ss->GetYLen(); y++) {
     if (Ss->At(0, y)[0] == '#') continue; // skip comments
     if (Ss->GetXLen(y) < 3) continue;     // there must be at least one author
     const int& SrcId = Ss->At(0, y).GetInt();
     IAssert(! Set1IdH.IsKey(SrcId));
     IAssert(! TimeNet.IsNode(SrcId));
     Set1IdH.AddKey(SrcId);
     Ss->At(1, y).SplitOnAllCh('-', StrTimeV);
     const int Year = StrTimeV[0].GetInt();
     const int Month = StrTimeV[1].GetInt();
     const int Day = StrTimeV[2].GetInt();
     const TSecTm NodeTm(Year, Month, Day);
     TimeNet.AddNode(SrcId, NodeTm);
     for (int dst = 2; dst < Ss->GetXLen(y); dst++) {
       const int DstId = Ss->At(dst, y).GetInt();
       IAssert(! Set1IdH.IsKey(DstId));
       if (! TimeNet.IsNode(DstId)) { TimeNet.AddNode(DstId, NodeTm); }
       else { TimeNet.GetNDat(DstId) = TMath::Mn(NodeTm, TimeNet.GetNDat(DstId)); }
       if (! TimeNet.IsEdge(SrcId, DstId)) { TimeNet.AddEdge(SrcId, DstId); }
     }
   }
   TimeNet.Defrag();
   printf("Bipartate graph: nodes: %d  edges: %d\n", TimeNet.GetNodes(), TimeNet.GetEdges());
   printf("  Bipartate sets: %d nodes --> %d nodes\n", TSnap::CntInDegNodes(TimeNetPt, 0),
     TSnap::CntOutDegNodes(TimeNetPt, 0));
   return TimeNetPt;
 }

PTimeNet TTimeNet::LoadPatents	(	const TStr &	PatentFNm,
		const TStr &	CiteFNm
	)

static

Definition at line 480 of file timenet.cpp.

                                                                          {
   int N = 0;
   TExeTm ExeTm;
   PTimeNet TimeNetPt = TTimeNet::New();
   TTimeNet& TimeNet = *TimeNetPt;
   TimeNet.Reserve(4000000, 160000000);
   printf("parsing patent data (patent grant year)...\n");
   // load time data (file pat63_99.txt)
   const int& PatIdCol = 0;
   const int& GYearCol = 1;
   TStrV ColV;
   char Line [1024];
   FILE *PatF = fopen(PatentFNm.CStr(), "rt");
   fgets(Line, 1024, PatF); // skip 1st line
   while (! feof(PatF)) {
     Line[0] = 0;
     fgets(Line, 1024, PatF);
     if (strlen(Line) == 0) break;
     TStr(Line).SplitOnAllCh(',', ColV, false);
     IAssert(ColV.Len() == 23);
     const int PatentId = ColV[PatIdCol].GetInt();
     const int GrantYear = ColV[GYearCol].GetInt();
     IAssert(! TimeNet.IsNode(PatentId));
     TimeNet.AddNode(PatentId, TSecTm(GrantYear)); // pretend year is a second
     if (++N % 100000 == 0) printf("\r  %dk", N/1000);
   }
   printf("\r  %d patents read. %s\n", N, ExeTm.GetTmStr());
   fclose(PatF);
   // load citations (file cite75_99.txt)
   printf("\nLoading patent citations...\n");
   int NewSrcIds=0, NewDstIds=0, DupLinks=0, NewCits=0;
   N = 0;  ExeTm.Tick();
   TStr SrcId, DstId;
   FILE *CiteF = fopen(CiteFNm.CStr(), "rt");
   fgets(Line, 1024, CiteF); // skip 1st line
   while (! feof(CiteF)) {
     Line[0] = 0;
     fgets(Line, 1024, CiteF);
     if (strlen(Line) == 0) break;
     Line[strlen(Line)-1] = 0; // delete trailing '\n'
     TStr(Line).SplitOnCh(SrcId, ',', DstId);
     const int SrcNId = SrcId.GetInt();
     const int DstNId = DstId.GetInt();
     if (! TimeNet.IsNode(SrcNId) && ! TimeNet.IsNode(DstNId)) {
       //TimeNet.AddNode(SrcNId, TSecTm(1, 1, 1));  NewSrcIds++;
       //TimeNet.AddNode(DstNId, TSecTm(1, 1, 1));  NewDstIds++;
       NewCits++;
       continue;
     }
     else if (TimeNet.IsNode(SrcNId) && ! TimeNet.IsNode(DstNId)) {
       TimeNet.AddNode(DstNId, TimeNet.GetNDat(SrcNId));  NewDstIds++;
     }
     else if (! TimeNet.IsNode(SrcNId) && TimeNet.IsNode(DstNId)) {
       TimeNet.AddNode(SrcNId, TimeNet.GetNDat(DstNId));  NewSrcIds++;
     }
     if (! TimeNet.IsEdge(SrcNId, DstNId)) {
       TimeNet.AddEdge(SrcNId, DstNId);
     } else { DupLinks++; }
     if (++N % 100000 == 0) printf("\r  %dk", N/1000);
   }
   fclose(CiteF);
   printf("\r  %d citations read. %s\n\n", N, ExeTm.GetTmStr());
   printf("Graph: nodes: %d    edges: %d\n", TimeNet.GetNodes(), TimeNet.GetEdges());
   printf("Removing 0-degree nodes: %d nodes\n", TSnap::CntDegNodes(TimeNetPt, 0));
   TIntV RmNIdV;
   for (TTimeNet::TNodeI ni = TimeNet.BegNI(); ni < TimeNet.EndNI(); ni++) {
     if (ni.GetDeg() == 0) { RmNIdV.Add(ni.GetId()); }
   }
   for (int i = 0; i < RmNIdV.Len(); i++) {
     TimeNet.DelNode(RmNIdV[i]);
   }
   TimeNet.Defrag(true);
   printf("\nFinal graph: nodes: %d    edges: %d\n", TimeNet.GetNodes(), TimeNet.GetEdges());
   printf("  Duplicate citations                    : %d\n", DupLinks);
   printf("  Citations between unknown time nodes   : %d\n", NewCits);
   printf("  Nodes without time which make citations: %d\n", NewSrcIds);
   printf("  Nodes without time which are cited     : %d\n", NewDstIds);
   return TimeNetPt;
 }

static PTimeNet TTimeNet::New ( )

inlinestatic

Definition at line 39 of file timenet.h.

39 { return new TTimeNet(); }

TTimeNet::TTimeNet

TTimeNet()

Definition: timenet.h:34

static PTimeNet TTimeNet::New	(	const int &	Nodes,
		const int &	Edges
	)

inlinestatic

Definition at line 40 of file timenet.h.

40 { return new TTimeNet(Nodes, Edges); }

TTimeNet::TTimeNet

TTimeNet()

Definition: timenet.h:34

TTimeNet & TTimeNet::operator= ( const TTimeNet & TimeNet )

Definition at line 3 of file timenet.cpp.

                                                        {
   if (this != &TimeNet) {
     TNet::operator=(TimeNet);
   }
   return *this;
 }

void TTimeNet::PlotCCfOverTm	(	const TStr &	FNmPref,
		TStr	Desc,
		const TTmUnit &	TmUnit,
		const int &	NodesBucket = `-1`
	)		const

Definition at line 253 of file timenet.cpp.

                                                                                                                 {
   if (Desc.Empty()) { Desc = FNmPref; }
   TTimeNet::TTmBucketV TmBucketV;
   TStr XLbl;
   if (TmUnit == tmuNodes) {
     XLbl = "Number of nodes (time)";
     IAssert(NodesBucket > 0);
     GetNodeBuckets(NodesBucket, TmBucketV); }
   else {
     XLbl = TStr::Fmt("Time (%s)", TTmInfo::GetTmUnitStr(TmUnit).CStr());
     GetTmBuckets(TmUnit, TmBucketV);
   }
   TIntV NodeIdV;
   TFltPrV DegToCCfV, CcfV, OpClV, OpV;
   TVec<TTuple<TFlt, 4> > OpenClsV;
   TTuple<TFlt, 4> Tuple;
   TExeTm ExeTm;
   int XVal = 0;
   printf("Clustering coefficient over time:\n  %d edges, %d edges per bucket, %d buckets \n", GetEdges(), 100000, TmBucketV.Len());
   PUNGraph UNGraph = TSnap::ConvertGraph<PUNGraph>(PTimeNet((TTimeNet*)this));
   for (int t = 0; t < TmBucketV.Len(); t++) {
     printf("\r  %d/%d: ", t+1, TmBucketV.Len());
     NodeIdV.AddV(TmBucketV[t].NIdV); // edges up to time T
     int64 Open=0, Close=0;
     const PUNGraph Graph = TSnap::GetSubGraph(UNGraph, NodeIdV);
     const double CCf = TSnap::GetClustCf(Graph, DegToCCfV, Open, Close);
     if (TmUnit == tmuNodes) { XVal = Graph->GetNodes(); }
     else { XVal = TmBucketV[t].BegTm.GetInUnits(TmUnit); }
     CcfV.Add(TFltPr(XVal, CCf));
     double FltOpen = static_cast<double>(Open);
     double FltClose = static_cast<double>(Close);
     OpClV.Add(TFltPr(XVal, (Open+Close==0 ? 0.0 : FltClose/(FltOpen+FltClose))));
     OpV.Add(TFltPr(XVal, (Open==0 ? 0.0 : FltClose/FltOpen)));
     Tuple[0]=Graph->GetNodes();
     Tuple[1]=Graph->GetEdges();
     Tuple[2]=FltClose;  Tuple[3]=FltOpen;
     OpenClsV.Add(Tuple);
     printf(" %s", ExeTm.GetStr());
     TGnuPlot::PlotValV(DegToCCfV, TStr::Fmt("ccfAt%02dtm.%s", t+1, FNmPref.CStr()),
       TStr::Fmt("%s. At time %d. Clustering Coefficient. G(%d,%d)", Desc.CStr(), t+1, Graph->GetNodes(), Graph->GetEdges()),
       "Degree", "Clustering coefficient", gpsLog10XY, false);
   }
   TGnuPlot::PlotValV(CcfV, "ccfOverTm."+FNmPref, Desc+". Average Clustering Coefficient", XLbl, "Average clustering coefficient", gpsAuto, false);
   TGnuPlot::PlotValV(OpClV, "ClsOpnTr1."+FNmPref, Desc+". Close/(Open+Closed) triads", XLbl, "Close / (Open+Closed) triads", gpsAuto, false);
   TGnuPlot::PlotValV(OpV, "ClsOpnTr2."+FNmPref, Desc+". Close/Open triads", XLbl, "Close / Open triads", gpsAuto, false);
   TGnuPlot::SaveTs(OpenClsV, "ClsOpnTr."+FNmPref+".tab", TStr::Fmt("#%s\n#Nodes\tEdges\tClosed\tOpenTriads", Desc.CStr()));
   printf("\n");
 }

void TTimeNet::PlotEffDiam	(	const TStr &	FNmPref,
		const TStr &	Desc,
		const TTmUnit &	GroupBy,
		const TSecTm &	StartTm,
		const int &	NDiamRuns = `10`,
		const bool &	OnlyWcc = `false`,
		const bool &	AlsoRewire = `false`
	)		const

Definition at line 106 of file timenet.cpp.

                                                                                                                            {
   const TStr WccStr = OnlyWcc ? "WCC " : TStr::GetNullStr();
   TTmBucketV TmBucketV;
   GetTmBuckets(TmUnit, TmBucketV);
   TIntV NodeIdV;
   TExeTm ExeTm, Run1Tm;
   TFltTrV TmDiamV, NdsDiamV;
   TFltTrV RwTmDiamV, RwNdsDiamV;
   for (int t = 0; t < TmBucketV.Len(); t++) {
     NodeIdV.AddV(TmBucketV[t].NIdV); // nodes up to time T
     printf("\n*** %d/%d] at %s (%d nodes)\n", t+1, TmBucketV.Len(),
       TmBucketV[t].BegTm.GetStr(TmUnit).CStr(), NodeIdV.Len());  ExeTm.Tick();
     if (TmBucketV[t].BegTm < StartTm) continue;
     //PUNGraph PreGraph = GetSubUNGraph(NodeIdV, true);
     PUNGraph PreGraph = TSnap::ConvertSubGraph<PUNGraph>(PTimeNet((TTimeNet*)this), NodeIdV);
     { TMom Mom;
     for (int r = 0; r < NDiamRuns; r++) {
       printf("%d...", r+1);  Run1Tm.Tick();
       const double EffDiam = TSnap::GetAnfEffDiam(OnlyWcc ? TSnap::GetMxWcc(PreGraph) : PreGraph);
       Mom.Add(EffDiam);  printf("[%s]\r", Run1Tm.GetTmStr());
     }
     Mom.Def();
     TmDiamV.Add(TFltTr((int)TmBucketV[t].BegTm.GetInUnits(TmUnit), Mom.GetMean(), Mom.GetSDev()));
     NdsDiamV.Add(TFltTr(PreGraph->GetNodes(), Mom.GetMean(), Mom.GetSDev()));
     NdsDiamV.Sort();
     printf("  [%s]          \n", ExeTm.GetTmStr()); }
     if (AlsoRewire) {
       //PUNGraph RwGraph = TGGen::GenRndDegSeqS(PreGraph, 50, TInt::Rnd); // edge switching model
       TIntV DegSeqV(PreGraph->GetNodes(), 0);
       for (TUNGraph::TNodeI NI = PreGraph->BegNI(); NI < PreGraph->EndNI(); NI++) { DegSeqV.Add(NI.GetDeg()); }
       PUNGraph RwGraph = TSnap::GenConfModel(DegSeqV, TInt::Rnd);
       printf("Configuration model: (%d, %d) --> (%d, %d)\n", PreGraph->GetNodes(), PreGraph->GetEdges(), RwGraph->GetNodes(), RwGraph->GetEdges());
       TMom Mom;
       for (int r = 0; r < NDiamRuns; r++) {
         printf("  diam run %d...", r+1);  Run1Tm.Tick();
         const double EffDiam = TSnap::GetAnfEffDiam(OnlyWcc ? TSnap::GetMxWcc(PreGraph):PreGraph);
         Mom.Add(EffDiam);  printf(" current run [%s]\n", Run1Tm.GetTmStr());
       }
       Mom.Def();
       RwTmDiamV.Add(TFltTr((int)TmBucketV[t].BegTm.GetInUnits(TmUnit), Mom.GetMean(), Mom.GetSDev()));
       RwNdsDiamV.Add(TFltTr(PreGraph->GetNodes(), Mom.GetMean(), Mom.GetSDev()));
       RwNdsDiamV.Sort();
       printf("done with diameter. Total time [%s] \n", ExeTm.GetTmStr());
     }
     // plot
     { TGnuPlot GnuPlot("diamEff-T."+FNmPref, TStr::Fmt("%s. G(%d, %d)", Desc.CStr(), GetNodes(), GetEdges()));
     GnuPlot.SetXYLabel(TStr::Fmt("TIME [%s]", TTmInfo::GetTmUnitStr(TmUnit).CStr()), WccStr+"Effective Diameter");
     GnuPlot.AddErrBar(TmDiamV, "True", "");
     if (! RwTmDiamV.Empty()) { GnuPlot.AddErrBar(RwTmDiamV, "Rewired", "");}
     GnuPlot.SavePng(); }
     { TGnuPlot GnuPlot("diamEff-N."+FNmPref, TStr::Fmt("%s. G(%d, %d)", Desc.CStr(), GetNodes(), GetEdges()));
     GnuPlot.SetXYLabel("NODES", WccStr+"Effective Diameter");
     GnuPlot.AddErrBar(NdsDiamV, "True", "");
     if (! RwNdsDiamV.Empty()) { GnuPlot.AddErrBar(RwNdsDiamV, "Rewired", "");}
     GnuPlot.SavePng(); }
   }
 }

void TTimeNet::PlotMedianDegOverTm	(	const TStr &	FNmPref,
		const TTmUnit &	TmUnit,
		const int &	NodesPerBucket = `-1`
	)		const

Definition at line 302 of file timenet.cpp.

                                                                                                               {
   TTimeNet::TTmBucketV TmBucketV;
   TStr XLbl;
   if (TmUnit == tmuNodes) {
     XLbl = "Number of nodes (time)";  IAssert(NodesPerBucket > 0);
     GetNodeBuckets(NodesPerBucket, TmBucketV); }
   else {
     XLbl = TStr::Fmt("Time (%s)", TTmInfo::GetTmUnitStr(TmUnit).CStr());
     GetTmBuckets(TmUnit, TmBucketV); }
   printf("\n\n%s\nMedian degree over time:\n  %d edges, %d edges per bucket, %d buckets \n", FNmPref.CStr(), GetEdges(), NodesPerBucket, TmBucketV.Len());
   TFltPrV MedDegV, MedInDegV, MedOutDegV;
   TIntV NodeIdV;
   int XVal;
   PUNGraph UNGraph = TSnap::ConvertGraph<PUNGraph>(PTimeNet((TTimeNet*)this));
   PNGraph NGraph = TSnap::ConvertGraph<PNGraph>(PTimeNet((TTimeNet*)this));
   FILE  *F = fopen(("gStat-"+FNmPref+".tab").CStr(), "wt");
   fprintf(F, "UndirNodes\tUndirEdges\tUndirNonZNodes\tMedianDeg\tMeanDeg\tDirNodes\tDirEdges\tDirNonzNodes\tMedInDeg\tMedOutDeg\tMeanInDeg\tMeanOutDeg\n");
   for (int t = 0; t < TmBucketV.Len(); t++) {
     printf("\r  %d/%d: ", t+1, TmBucketV.Len());
     NodeIdV.AddV(TmBucketV[t].NIdV); // edges up to time T
     if (TmUnit == tmuNodes) { XVal = NodeIdV.Len(); }
     else { XVal = TmBucketV[t].BegTm.GetInUnits(TmUnit); }
     // un graph
     { const PUNGraph Graph = TSnap::GetSubGraph(UNGraph, NodeIdV);  TMom Mom;
     for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) { if (NI.GetOutDeg()>0) { Mom.Add(NI.GetOutDeg());} }
     Mom.Def();  MedDegV.Add(TFltPr(XVal, Mom.GetMedian()));
     fprintf(F, "%d\t%d\t%d\t%f\t%f", Graph->GetNodes(), Graph->GetEdges(), TSnap::CntNonZNodes(Graph), (float)Mom.GetMedian(), (float)Mom.GetMean()); }
     // directed graph
     { const PNGraph Graph = TSnap::GetSubGraph<PNGraph>(NGraph, NodeIdV); TMom MomOut, MomIn;
     for (TNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
       if (NI.GetOutDeg()>0) { MomOut.Add(NI.GetOutDeg()); }
       if (NI.GetInDeg()>0) { MomIn.Add(NI.GetInDeg()); } }
     MomOut.Def();  MedOutDegV.Add(TFltPr(XVal, MomOut.GetMedian()));
     MomIn.Def();  MedInDegV.Add(TFltPr(XVal, MomIn.GetMedian()));
     fprintf(F, "\t%d\t%d\t%d\t%f\t%f\t%f\t%f\n", Graph->GetNodes(), Graph->GetEdges(), (int)TSnap::CntNonZNodes(Graph), (float)MomIn.GetMedian(), (float)MomOut.GetMedian(), (float)MomIn.GetMean(), (float)MomOut.GetMean()); }
   }
   fclose(F);
   TGnuPlot::PlotValV(MedDegV, "medDeg."+FNmPref, FNmPref+" Median degree", TTmInfo::GetTmUnitStr(TmUnit), "Median degree");
   TGnuPlot::PlotValV(MedOutDegV, "medOutDeg."+FNmPref, FNmPref+" Median OUT degree", TTmInfo::GetTmUnitStr(TmUnit), "Median OUT degree");
   TGnuPlot::PlotValV(MedInDegV, "medInDeg."+FNmPref, FNmPref+" Median IN degree", TTmInfo::GetTmUnitStr(TmUnit), "Median IN degree");
 }

void TTimeNet::PlotMissingPast	(	const TStr &	FNmPref,
		const TStr &	Desc,
		const TTmUnit &	GroupBy,
		const TSecTm &	DelPreTmEdges,
		const TSecTm &	PostTmDiam
	)		const

Definition at line 169 of file timenet.cpp.

                                                                                             {
   printf("\nGrowth over time: degree distribution, Growth Power Law, Diameter.\n  %s group by %s.\n",
     FNmPref.CStr(), TTmInfo::GetTmUnitStr(TmUnit).CStr());
   printf("  Delete out-edges of pre time %s nodes.\n  Take subgraph of post year %s subgraph.\n\n",
     DelPreTmEdges.GetStr().CStr(), PostTmDiam.GetStr().CStr());
   const int NDiamRuns = 10;
   const int NSamples = 100;
   //PUNGraph FullGraph = GetUNGraph();
   PUNGraph FullGraph = TSnap::ConvertGraph<PUNGraph>(PTimeNet((TTimeNet*)this));
   // delete past
   if (DelPreTmEdges.IsDef()) {
     int NDelNodes = 0, NDelEdges = 0;
     printf("Deleting pre-%s node out-links\n", DelPreTmEdges.GetStr().CStr());
     for (TNodeI NodeI = BegNI(); NodeI < EndNI(); NodeI++) {
       if (NodeI() < DelPreTmEdges) {
         const int NodeId = NodeI.GetId();
         for (int edge = 0; edge < NodeI.GetOutDeg(); edge++) {
           FullGraph->DelEdge(NodeId, NodeI.GetOutNId(edge)); }
         NDelEdges += NodeI.GetOutDeg();  NDelNodes++;
       }
     }
     printf("  Deleted %d nodes out-edges (%d edges total).\n", NDelNodes, NDelEdges);
     FullGraph->Defrag(true);
   }
   PGStatVec GrowthStat = TGStatVec::New(TmUnit);
   TFltV PreDiamSDev, PreEffDiamSDev, WccDiamSDev, WccEffDiamSDev;
   TIntV NodeIdV;
   TExeTm ExeTm;
   TTmBucketV TmBucketV;
   GetTmBuckets(TmUnit, TmBucketV);
   for (int t = 0; t < TmBucketV.Len(); t++) {
     printf("\nGraph: %s (%d / %d) [%s]\n", TmBucketV[t].BegTm.GetTmStr().CStr(),
       t+1, TmBucketV.Len(), TExeTm::GetCurTm());
     // up-to-year subgraph
     NodeIdV.AddV(TmBucketV[t].NIdV); // nodes up to time T
     if (TmBucketV[t].BegTm < PostTmDiam) { continue; }
     const PUNGraph PreGraph = TSnap::GetSubGraph(FullGraph, NodeIdV, true);
     const PUNGraph WccGraph = TSnap::GetMxWcc(PreGraph);
     TIntV PostYearNIdV, WccPostYearNIdV;
     for (TUNGraph::TNodeI NI = PreGraph->BegNI(); NI < PreGraph->EndNI(); NI++) {
       if (GetNDat(NI.GetId()) >= PostTmDiam) {
         PostYearNIdV.Add(NI.GetId());
         if (WccGraph->IsNode(NI.GetId())) { WccPostYearNIdV.Add(NI.GetId()); }
       }
     }
     TMom PreDiamMom, PreEffDiamMom, WccDiamMom, WccEffDiamMom;
     // diameter of PostYearDiam subgraph using whole graph (all edges)
     int FullDiam; double EffDiam;
     for (int r = 0; r < NDiamRuns; r++) {
       if (! PostYearNIdV.Empty()) {
         TSnap::GetBfsEffDiam(PreGraph, NSamples, PostYearNIdV, false, EffDiam, FullDiam);
         PreDiamMom.Add(FullDiam);  PreEffDiamMom.Add(EffDiam);
       }
       if (! WccPostYearNIdV.Empty()) {
         TSnap::GetBfsEffDiam(WccGraph, NSamples, WccPostYearNIdV, false, EffDiam, FullDiam);
         WccDiamMom.Add(FullDiam);  WccEffDiamMom.Add(EffDiam);
       }
       printf("  diam: %d  [%s]  \r", r+1, ExeTm.GetTmStr());  ExeTm.Tick();
     }
     PreDiamMom.Def();  PreEffDiamMom.Def();
     WccDiamMom.Def();  WccEffDiamMom.Def();
     // save stat
     PGStat GraphStatPt = GrowthStat->Add(TmBucketV[t].BegTm);
     TGStat& GS = *GraphStatPt;
     GS.TakeBasicStat(PreGraph, false);
     GS.TakeBasicStat(WccGraph, true);
     GS.SetVal(gsvFullDiam, PreDiamMom.GetMean()); // mean
     GS.SetVal(gsvEffDiam, PreEffDiamMom.GetMean());
     GS.SetVal(gsvFullWccDiam, WccDiamMom.GetMean());
     GS.SetVal(gsvEffWccDiam, WccEffDiamMom.GetMean());
     GS.SetVal(gsvFullDiamDev, PreDiamMom.GetSDev()); // variance
     GS.SetVal(gsvEffDiamDev, PreEffDiamMom.GetSDev());
     GS.SetVal(gsvFullWccDiamDev, WccDiamMom.GetSDev());
     GS.SetVal(gsvEffWccDiamDev, WccEffDiamMom.GetSDev());
     { TFOut FOut("growth."+FNmPref+".gStatVec");  GrowthStat->Save(FOut); }
     GrowthStat->SaveTxt(FNmPref, TStr::Fmt("%s. MISSING PAST DIAMETER\nDelPreEdges\t%s\nPostYearDiam\t%s\n",
       Desc.CStr(), DelPreTmEdges.GetStr().CStr(), PostTmDiam.GetStr().CStr()));
   }
   // diameter plots
   //GrowthStat->PlotDiam(FNmPref, Desc + TStr::Fmt(" MISSING PAST. DelPre:%d PostYear:%d.",
   //  DelPreEdges, PostYearDiam));*/
 }

void TTimeNet::Save ( TSOut & SOut ) const

inlinevirtual

Saves the network to a (binary) stream SOut.

Reimplemented from TNodeNet< TSecTm >.

Definition at line 38 of file timenet.h.

38 { TNet::Save(SOut); }

TNodeNet< TSecTm >::Save

virtual void Save(TSOut &SOut) const

Saves the network to a (binary) stream SOut.

Definition: network.h:168

PGStatVec TTimeNet::TimeGrowth	(	const TTmUnit &	TmUnit,
		const TFSet &	TakeStat,
		const TSecTm &	StartTm
	)		const

Definition at line 88 of file timenet.cpp.

                                                                                                         {
   PGStatVec GrowthStat = new TGStatVec(TmUnit, TakeStat);
   TTmBucketV TmBucketV;
   GetTmBuckets(TmUnit, TmBucketV);
   TIntV NodeIdV;
   TExeTm ExeTm;
   for (int t = 0; t < TmBucketV.Len(); t++) {
     NodeIdV.AddV(TmBucketV[t].NIdV); // nodes up to time T
     printf("\n=== %d/%d] %s (%d nodes)\n", t+1, TmBucketV.Len(),
       TmBucketV[t].BegTm.GetStr().CStr(), NodeIdV.Len());  ExeTm.Tick();
     if (TmBucketV[t].BegTm < StartTm) continue;
     //PNGraph PreGraph = GetSubGraph(NodeIdV, true); // renumber nodes
     PNGraph PreGraph = TSnap::ConvertSubGraph<PNGraph>(PTimeNet((TTimeNet*)this), NodeIdV); // don't renumber nodes
     GrowthStat->Add(PreGraph, TmBucketV[t].BegTm);
   }
   return GrowthStat;
 }

Friends And Related Function Documentation

friend class TPt< TTimeNet >

friend

Definition at line 65 of file timenet.h.

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

snap-core/timenet.h
snap-core/timenet.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation