TSnap Namespace Reference

Main namespace for all the Snap global entities. More...

Namespaces
	TSnapDetail

Classes
struct	IsBipart
	Tests (at compile time) if the graph is a bipartite graph type. More...
struct	IsBipart< TBPGraph >
struct	IsDirected
	Tests (at compile time) if the graph is directed. More...
struct	IsDirected< TBigNet< TNodeData, IsDir > >
struct	IsDirected< TBigNet< TNodeData, true > >
struct	IsDirected< TDirNet >
struct	IsDirected< TModeNet >
struct	IsDirected< TNEANet >
struct	IsDirected< TNEANetMP >
struct	IsDirected< TNEGraph >
struct	IsDirected< TNGraph >
struct	IsDirected< TNGraphMP >
struct	IsDirected< TNodeEDatNet< TNodeData, TEdgeData > >
struct	IsDirected< TNodeEdgeNet< TNodeData, TEdgeData > >
struct	IsDirected< TNodeNet< TNodeData > >
struct	IsDirected< TTimeNENet >
struct	IsDirected< TTimeNet >
struct	IsEdgeDat
	Tests (at compile time) if the graph is a network with data on edges. More...
struct	IsEdgeDat< TNodeEDatNet< TNodeData, TEdgeData > >
struct	IsEdgeDat< TNodeEdgeNet< TNodeData, TEdgeData > >
struct	IsEdgeDat< TTimeNENet >
struct	IsMultiGraph
	Tests (at compile time) if the graph is a multigraph with multiple edges between the same nodes. More...
struct	IsMultiGraph< TModeNet >
struct	IsMultiGraph< TNEANet >
struct	IsMultiGraph< TNEANetMP >
struct	IsMultiGraph< TNEGraph >
struct	IsMultiGraph< TNodeEdgeNet< TNodeData, TEdgeData > >
struct	IsMultiGraph< TTimeNENet >
struct	IsNodeDat
	Tests (at compile time) if the graph is a network with data on nodes. More...
struct	IsNodeDat< TBigNet< TNodeData, IsDir > >
struct	IsNodeDat< TNodeEDatNet< TNodeData, TEdgeData > >
struct	IsNodeDat< TNodeEdgeNet< TNodeData, TEdgeData > >
struct	IsNodeDat< TNodeNet< TNodeData > >
struct	IsNodeDat< TTimeNENet >
struct	IsNodeDat< TTimeNet >
struct	IsSources
	Tests (at compile time) if the nodes store only out-edges, but not in-edges. More...
class	TPRManager
	Push relabel attr manager. More...

Functions
template<class PGraph >
int	CntInDegNodes (const PGraph &Graph, const int &NodeInDeg)
	Returns the number of nodes with in-degree NodeInDeg. More...
template<class PGraph >
int	CntOutDegNodes (const PGraph &Graph, const int &NodeOutDeg)
	Returns the number of nodes with out-degree NodeOutDeg. More...
template<class PGraph >
int	CntDegNodes (const PGraph &Graph, const int &NodeDeg)
	Returns the number of nodes with degree NodeDeg. More...
template<class PGraph >
int	CntNonZNodes (const PGraph &Graph)
	Returns the number of nodes with degree greater than 0. More...
template<class PGraph >
int	CntEdgesToSet (const PGraph &Graph, const int &NId, const TIntSet &NodeSet)
	Returns the number of nodes in NodeSet that have an edge to the node NId. More...
template<class PGraph >
int	GetMxDegNId (const PGraph &Graph)
	Returns a randomly chosen node from all the nodes with the maximum degree. More...
template<class PGraph >
int	GetMxInDegNId (const PGraph &Graph)
	Returns a randomly chosen node from all the nodes with the maximum in-degree. More...
template<class PGraph >
int	GetMxOutDegNId (const PGraph &Graph)
	Returns a randomly chosen node from all the nodes with the maximum out-degree. More...
template<class PGraph >
void	GetInDegCnt (const PGraph &Graph, TIntPrV &DegToCntV)
	Returns an in-degree histogram: a set of pairs (in-degree, number of nodes of such in-degree) More...
template<class PGraph >
void	GetInDegCnt (const PGraph &Graph, TFltPrV &DegToCntV)
	Returns an in-degree histogram: a set of pairs (in-degree, number of nodes of such in-degree) More...
template<class PGraph >
void	GetOutDegCnt (const PGraph &Graph, TIntPrV &DegToCntV)
	Returns an out-degree histogram: a set of pairs (out-degree, number of nodes of such out-degree) More...
template<class PGraph >
void	GetOutDegCnt (const PGraph &Graph, TFltPrV &DegToCntV)
	Returns an out-degree histogram: a set of pairs (out-degree, number of nodes of such out-degree) More...
template<class PGraph >
void	GetDegCnt (const PGraph &Graph, TIntPrV &DegToCntV)
	Returns a degree histogram: a set of pairs (degree, number of nodes of such degree) More...
template<class PGraph >
void	GetDegCnt (const PGraph &Graph, TFltPrV &DegToCntV)
	Returns a degree histogram: a set of pairs (degree, number of nodes of such degree) More...
template<class PGraph >
void	GetDegSeqV (const PGraph &Graph, TIntV &DegV)
	Returns a degree sequence vector. More...
template<class PGraph >
void	GetDegSeqV (const PGraph &Graph, TIntV &InDegV, TIntV &OutDegV)
	Returns an in- and out-degree sequence vectors. More...
template<class PGraph >
void	GetNodeInDegV (const PGraph &Graph, TIntPrV &NIdInDegV)
	Returns a vector of pairs (node id, node in-degree) More...
template<class PGraph >
void	GetNodeOutDegV (const PGraph &Graph, TIntPrV &NIdOutDegV)
	Returns a vector of pairs (node id, node out-degree) More...
template<class PGraph >
int	CntUniqUndirEdges (const PGraph &Graph)
	Counts unique undirected edges in the graph Graph. Nodes (u,v) (where u!=v) are connected via an undirected edge if there exists an edge in either direction (u,v) or (v,u). More...
template<class PGraph >
int	CntUniqDirEdges (const PGraph &Graph)
	Counts unique directed edges in the graph Graph. Nodes (u,v) (where u!=v) are connected via a directed edge if there exists a directed edge from node u to node v. More...
template<class PGraph >
int	CntUniqBiDirEdges (const PGraph &Graph)
	Counts unique bidirectional edges in the graph Graph. Edge is bidirectional if there exist directed edges in both directions: (u,v) and (v,u) More...
template<class PGraph >
int	CntSelfEdges (const PGraph &Graph)
	Counts the number of self-edges in a graph. Edge (u,u) is a self-edge. More...
template<class PGraph >
PGraph	GetUnDir (const PGraph &Graph)
	Returs an undirected version of the graph. For every edge (u,v) an edge (v,u) is added (if it does not yet exist). More...
template<class PGraph >
void	MakeUnDir (const PGraph &Graph)
	Makes the graph undirected. For every edge (u,v) an edge (v,u) is added (if it does not yet exist). More...
template<class PGraph >
void	AddSelfEdges (const PGraph &Graph)
	Adds a self-edge to every node in the graph. More...
template<class PGraph >
void	DelSelfEdges (const PGraph &Graph)
	Removes all the self-edges from the graph. More...
template<class PGraph >
void	DelNodes (PGraph &Graph, const TIntV &NIdV)
	Removes nodes with ids stored in NIdV from the graph. More...
template<class PGraph >
void	DelZeroDegNodes (PGraph &Graph)
	Removes all the zero-degree nodes, that isolated nodes, from the graph. More...
template<class PGraph >
void	DelDegKNodes (PGraph &Graph, const int &OutDegK, const int &InDegK)
	Removes all the node of out-degree OutDegK and all the nodes of in-degree InDegK from the graph. More...
template<class PGraph >
bool	IsTree (const PGraph &Graph, int &RootNIdX)
template<class PGraph >
int	GetTreeRootNId (const PGraph &Graph)
template<class PGraph >
void	GetTreeSig (const PGraph &Graph, const int &RootNId, TIntV &Sig)
template<class PGraph >
void	GetTreeSig (const PGraph &Graph, const int &RootNId, TIntV &Sig, TIntPrV &NodeMap)
template<class PGraph >
void	GetAnf (const PGraph &Graph, const int &SrcNId, TIntFltKdV &DistNbrsV, const int &MxDist, const bool &IsDir, const int &NApprox=32)
template<class PGraph >
void	GetAnf (const PGraph &Graph, TIntFltKdV &DistNbrsV, const int &MxDist, const bool &IsDir, const int &NApprox=32)
template<class PGraph >
double	GetAnfEffDiam (const PGraph &Graph, const bool &IsDir, const double &Percentile, const int &NApprox)
template<class PGraph >
double	GetAnfEffDiam (const PGraph &Graph, const int NRuns=1, int NApprox=-1)
template<class PGraph >
void	TestAnf ()
template<class PGraph >
PNGraph	GetBfsTree (const PGraph &Graph, const int &StartNId, const bool &FollowOut, const bool &FollowIn)
	Returns a directed Breadth-First-Search tree rooted at StartNId. More...
template<class PGraph >
int	GetSubTreeSz (const PGraph &Graph, const int &StartNId, const bool &FollowOut, const bool &FollowIn, int &TreeSzX, int &TreeDepthX)
	Returns the BFS tree size (number of nodes) and depth (number of levels) by following in-links (parameter FollowIn = true) and/or out-links (parameter FollowOut = true) of node StartNId. More...
template<class PGraph >
int	GetNodesAtHop (const PGraph &Graph, const int &StartNId, const int &Hop, TIntV &NIdV, const bool &IsDir=false)
	Finds IDs of all nodes that are at distance Hop from node StartNId. More...
template<class PGraph >
int	GetNodesAtHops (const PGraph &Graph, const int &StartNId, TIntPrV &HopCntV, const bool &IsDir=false)
	Returns the number of nodes at each hop distance from the starting node StartNId. More...
template<class PGraph >
int	GetShortPath (const PGraph &Graph, const int &SrcNId, const int &DstNId, const bool &IsDir=false)
	Returns the length of the shortest path from node SrcNId to node DstNId. More...
template<class PGraph >
int	GetShortPath (const PGraph &Graph, const int &SrcNId, TIntH &NIdToDistH, const bool &IsDir=false, const int &MaxDist=TInt::Mx)
	Returns the length of the shortest path from node SrcNId to all other nodes in the network. More...
template<class PGraph >
int	GetBfsFullDiam (const PGraph &Graph, const int &NTestNodes, const bool &IsDir=false)
	Returns the (approximation of the) Diameter (maximum shortest path length) of a graph (by performing BFS from NTestNodes random starting nodes). More...
template<class PGraph >
double	GetBfsEffDiam (const PGraph &Graph, const int &NTestNodes, const bool &IsDir=false)
	Returns the (approximation of the) Effective Diameter (90-th percentile of the distribution of shortest path lengths) of a graph (by performing BFS from NTestNodes random starting nodes). More...
template<class PGraph >
double	GetBfsEffDiam (const PGraph &Graph, const int &NTestNodes, const bool &IsDir, double &EffDiamX, int &FullDiamX)
	Returns the (approximation of the) Effective Diameter and the Diameter of a graph (by performing BFS from NTestNodes random starting nodes). More...
template<class PGraph >
double	GetBfsEffDiam (const PGraph &Graph, const int &NTestNodes, const bool &IsDir, double &EffDiamX, int &FullDiamX, double &AvgSPLX)
	Returns the (approximation of the) Effective Diameter, the Diameter and the Average Shortest Path length in a graph (by performing BFS from NTestNodes random starting nodes). More...
template<class PGraph >
double	GetBfsEffDiamAll (const PGraph &Graph, const int &NTestNodes, const bool &IsDir, double &EffDiamX, int &FullDiamX, double &AvgSPLX)
	Returns the (approximation of the) Effective Diameter, the Diameter and the Average Shortest Path length in a graph (by performing BFS from NTestNodes random starting nodes). More...
template<class PGraph >
double	GetBfsEffDiam (const PGraph &Graph, const int &NTestNodes, const TIntV &SubGraphNIdV, const bool &IsDir, double &EffDiamX, int &FullDiamX)
	Use the whole graph (all edges) to measure the shortest path lengths but only report the path lengths between nodes in the SubGraphNIdV. More...
template<class PGraph >
int	GetShortestDistances (const PGraph &Graph, const int &StartNId, const bool &FollowOut, const bool &FollowIn, TIntV &ShortestDists)
template<class PGraph >
int	GetShortestDistancesMP2 (const PGraph &Graph, const int &StartNId, const bool &FollowOut, const bool &FollowIn, TIntV &ShortestDists)
PNGraph	CascGraphSource (PTable P, const TStr C1, const TStr C2, const TStr C3, const TStr C4, const TInt W)
	Takes as input the column names of the PTable P as C1, C2,C3 and C4 and returns a directed graph of W-adjacent events. For graph generation events are sorted by C1. More...
PNGraph	CascGraphTime (PTable P, const TStr C1, const TStr C2, const TStr C3, const TStr C4, const TInt W)
	Takes as input the column names of the PTable P as C1, C2,C3 and C4 and returns a directed graph of W-adjacent events. For graph generation events are sorted by C3. More...
PNGraph	CascGraph (PTable P, const TStr C1, const TStr C2, const TStr C3, const TStr C4, const TInt W, bool SortParam=true)
	Takes as input the column names of the PTable P as C1, C2, C3 and C4 and returns a directed graph of W-adjacent events. By default calls CascGraphSource. Toggle SortParam to use CascGraphTime. More...
void	CascFind (PNGraph Graph, PTable P, const TStr C1, const TStr C2, const TStr C3, const TStr C4, TVec< TIntV > &TopCascVV, bool Print=false)
	Takes as input a directed graph and returns all the top cascades in TopCascVV. More...
void	CascFindMP (PNGraph Graph, PTable P, const TStr C1, const TStr C2, const TStr C3, const TStr C4, TVec< TIntV > &TopCascVV)
	Parallel implementaion of CascFind takes as input a directed graph and returns all the top cascades in TopCascVV. More...
double	GetDegreeCentr (const PUNGraph &Graph, const int &NId)
void	GetEigenVectorCentr (const PUNGraph &Graph, TIntFltH &NIdEigenH, const double &Eps, const int &MaxIter)
double	GetGroupDegreeCentr (const PUNGraph &Graph, const PUNGraph &Group)
double	GetGroupDegreeCentr0 (const PUNGraph &Graph, const TIntH &GroupNodes)
double	GetGroupDegreeCentr (const PUNGraph &Graph, const TIntH &GroupNodes)
double	GetGroupFarnessCentr (const PUNGraph &Graph, const TIntH &GroupNodes)
PUNGraph *	AllGraphsWithNNodes (int n)
TIntH *	AllCombinationsMN (int m, int n)
double	GetGroupClosenessCentr (const PUNGraph &Graph, const TIntH &GroupNodes)
TIntH	MaxCPGreedyBetter (const PUNGraph &Graph, const int k)
	Returns centrality Maximum k group. More...
TIntH	MaxCPGreedyBetter1 (const PUNGraph &Graph, const int k)
	Returns centrality Maximum k group. More...
TIntH	MaxCPGreedyBetter2 (const PUNGraph &Graph, const int k)
	Returns centrality Maximum k group. More...
TIntH	MaxCPGreedyBetter3 (const PUNGraph &Graph, const int k)
	Returns centrality Maximum k group. More...
int	GetWeightedPageRank (const PNEANet Graph, TIntFltH &PRankH, const TStr &Attr, const double &C=0.85, const double &Eps=1e-4, const int &MaxIter=100)
	Weighted PageRank (TODO: Use template) More...
int	GetWeightedPageRankMP (const PNEANet Graph, TIntFltH &PRankH, const TStr &Attr, const double &C, const double &Eps, const int &MaxIter)
TIntFltH	EventImportance (const PNGraph &Graph, const int k)
	Event importance. More...
TIntFltH	EventImportance1 (const PNGraph &Graph, const int k)
int	Intersect (TUNGraph::TNodeI Node, TIntH NNodes)
	Intersect. More...
int	Intersect (TUNGraph::TNodeI Node, TStr NNodes)
	Intersect. More...
int	Intersect (TUNGraph::TNodeI Node, int *NNodes, int NNodes_br)
	Intersect. More...
int	Intersect1 (TUNGraph::TNodeI Node, TStr NNodes)
TIntH	LoadNodeList (TStr InFNmNodes)
int	findMinimum (TIntV &Frontier, TIntFltH &NIdDistH)
int	GetWeightedShortestPath (const PNEANet Graph, const int &SrcNId, TIntFltH &NIdDistH, const TFltV &Attr)
double	GetWeightedFarnessCentr (const PNEANet Graph, const int &NId, const TFltV &Attr, const bool &Normalized, const bool &IsDir)
double	GetWeightedClosenessCentr (const PNEANet Graph, const int &NId, const TFltV &Attr, const bool &Normalized, const bool &IsDir)
void	GetWeightedBetweennessCentr (const PNEANet Graph, const TIntV &BtwNIdV, TIntFltH &NodeBtwH, const bool &DoNodeCent, TIntPrFltH &EdgeBtwH, const bool &DoEdgeCent, const TFltV &Attr, const bool &IsDir)
	Computes (approximate) weighted Beetweenness Centrality of all nodes and all edges of the network. More...
void	GetWeightedBetweennessCentr (const PNEANet Graph, TIntFltH &NodeBtwH, TIntPrFltH &EdgeBtwH, const TFltV &Attr, const double &NodeFrac, const bool &IsDir)
void	GetWeightedBetweennessCentr (const PNEANet Graph, TIntFltH &NodeBtwH, const TFltV &Attr, const double &NodeFrac, const bool &IsDir)
void	GetWeightedBetweennessCentr (const PNEANet Graph, TIntPrFltH &EdgeBtwH, const TFltV &Attr, const double &NodeFrac, const bool &IsDir)
TTableIterator	GetMapPageRank (const TVec< PNEANet > &GraphSeq, TTableContext *Context, const double &C=0.85, const double &Eps=1e-4, const int &MaxIter=100)
	Gets sequence of PageRank tables from given GraphSeq. More...
TTableIterator	GetMapHitsIterator (const TVec< PNEANet > &GraphSeq, TTableContext *Context, const int &MaxIter=20)
	Gets sequence of Hits tables from given GraphSeq. More...
template<class PGraph >
double	GetFarnessCentr (const PGraph &Graph, const int &NId, const bool &Normalized=true, const bool &IsDir=false)
template<class PGraph >
double	GetFarnessCentrMP (const PGraph &Graph, const int &NId, const bool &Normalized=true, const bool &IsDir=false)
template<class PGraph >
double	GetClosenessCentr (const PGraph &Graph, const int &NId, const bool &Normalized=true, const bool &IsDir=false)
template<class PGraph >
double	GetClosenessCentrMP (const PGraph &Graph, const int &NId, const bool &Normalized=true, const bool &IsDir=false)
template<class PGraph >
int	GetNodeEcc (const PGraph &Graph, const int &NId, const bool &IsDir=false)
template<class PGraph >
void	GetBetweennessCentr (const PGraph &Graph, TIntFltH &NIdBtwH, const double &NodeFrac=1.0, const bool &IsDir=false)
template<class PGraph >
void	GetBetweennessCentr (const PGraph &Graph, TIntPrFltH &EdgeBtwH, const double &NodeFrac=1.0, const bool &IsDir=false)
template<class PGraph >
void	GetBetweennessCentr (const PGraph &Graph, TIntFltH &NIdBtwH, TIntPrFltH &EdgeBtwH, const double &NodeFrac=1.0, const bool &IsDir=false)
template<class PGraph >
void	GetBetweennessCentr (const PGraph &Graph, const TIntV &BtwNIdV, TIntFltH &NodeBtwH, const bool &DoNodeCent, TIntPrFltH &EdgeBtwH, const bool &DoEdgeCent, const bool &IsDir)
template<class PGraph >
void	GetPageRank (const PGraph &Graph, TIntFltH &PRankH, const double &C=0.85, const double &Eps=1e-4, const int &MaxIter=100)
template<class PGraph >
void	GetPageRank_v1 (const PGraph &Graph, TIntFltH &PRankH, const double &C=0.85, const double &Eps=1e-4, const int &MaxIter=100)
template<class PGraph >
void	GetPageRankMP (const PGraph &Graph, TIntFltH &PRankH, const double &C=0.85, const double &Eps=1e-4, const int &MaxIter=100)
template<class PGraph >
void	GetHits (const PGraph &Graph, TIntFltH &NIdHubH, TIntFltH &NIdAuthH, const int &MaxIter=20)
template<class PGraph >
void	GetHitsMP (const PGraph &Graph, TIntFltH &NIdHubH, TIntFltH &NIdAuthH, const int &MaxIter=20)
template<class PGraph >
void	MapPageRank (const TVec< PGraph > &GraphSeq, TVec< PTable > &TableSeq, TTableContext *Context, const double &C, const double &Eps, const int &MaxIter)
	Gets sequence of PageRank tables from given GraphSeq into TableSeq. More...
template<class PGraph >
void	MapHits (const TVec< PGraph > &GraphSeq, TVec< PTable > &TableSeq, TTableContext *Context, const int &MaxIter)
	Gets sequence of Hits tables from given GraphSeq into TableSeq. More...
double	CommunityGirvanNewman (PUNGraph &Graph, TCnComV &CmtyV)
double	Infomap (PUNGraph &Graph, TCnComV &CmtyV)
double	InfomapOnline (PUNGraph &Graph, int n1, int n2, TIntFltH &PAlpha, double &SumPAlphaLogPAlpha, TIntFltH &Qi, TIntH &Module, int &Br, TCnComV &CmtyV)
void	CmtyEvolutionFileBatchV (TStr InFNm, TIntIntVH &sizesContV, TIntIntVH &cContV, TIntIntVH &edges, double alpha, double beta, int CmtyAlg)
void	CmtyEvolutionFileBatch (TStr InFNm, TIntIntHH &sizesCont, TIntIntHH &cCont, TIntIntVH &edges, double alpha, double beta, int CmtyAlg)
void	CmtyEvolutionJson (TStr &Json, TIntIntVH &sizesContV, TIntIntVH &cContV, TIntIntVH &edges)
TStr	CmtyTest (TStr InFNm, int CmtyAlg)
void	ReebSimplify (PNGraph &Graph, TIntH &t, int e, PNGraph &gFinal, TIntH &tFinal, bool collapse)
void	ReebRefine (PNGraph &Graph, TIntH &t, int e, PNGraph &gFinal, TIntH &tFinal, bool collapse)
double	CommunityCNM (const PUNGraph &Graph, TCnComV &CmtyV)
template<typename PGraph >
double	GetModularity (const PGraph &G, const TIntV &NIdV, int GEdges=-1)
template<typename PGraph >
double	GetModularity (const PGraph &G, const TCnComV &CmtyV, int GEdges=-1)
template<typename PGraph >
void	GetEdgesInOut (const PGraph &Graph, const TIntV &NIdV, int &EdgesInX, int &EdgesOutX)
void	GetBiConSzCnt (const PUNGraph &Graph, TIntPrV &SzCntV)
	Returns a distribution of bi-connected component sizes. More...
void	GetBiCon (const PUNGraph &Graph, TCnComV &BiCnComV)
	Returns all bi-connected components of a Graph. More...
void	GetArtPoints (const PUNGraph &Graph, TIntV &ArtNIdV)
	Returns articulation points of a Graph. More...
void	GetEdgeBridges (const PUNGraph &Graph, TIntPrV &EdgeV)
	Returns bridge edges of a Graph. More...
void	Get1CnComSzCnt (const PUNGraph &Graph, TIntPrV &SzCntV)
	Distribution of sizes of 1-components, maximal number of components that can be disconnected from the Graph by removing a single edge. More...
void	Get1CnCom (const PUNGraph &Graph, TCnComV &Cn1ComV)
	Returns 1-components: maximal connected components of that can be disconnected from the Graph by removing a single edge. More...
PUNGraph	GetMxBiCon (const PUNGraph &Graph, const bool &RenumberNodes=false)
	Returns a graph representing the largest bi-connected component on an undirected Graph. More...
template<class PGraph >
void	GetNodeWcc (const PGraph &Graph, const int &NId, TIntV &CnCom)
	Returns (via output parameter CnCom) all nodes that are in the same connected component as node NId. More...
template<class PGraph >
bool	IsConnected (const PGraph &Graph)
	Tests whether the Graph is (weakly) connected. More...
template<class PGraph >
bool	IsWeaklyConn (const PGraph &Graph)
	Tests whether the Graph is weakly connected. More...
template<class PGraph >
void	GetWccSzCnt (const PGraph &Graph, TIntPrV &WccSzCnt)
	Returns a distribution of weakly connected component sizes. More...
template<class PGraph >
void	GetWccs (const PGraph &Graph, TCnComV &CnComV)
	Returns all weakly connected components in a Graph. More...
template<class PGraph >
void	GetSccSzCnt (const PGraph &Graph, TIntPrV &SccSzCnt)
	Returns a distribution of strongly connected component sizes. More...
template<class PGraph >
void	GetSccs (const PGraph &Graph, TCnComV &CnComV)
	Returns all strongly connected components in a Graph. More...
template<class PGraph >
double	GetMxWccSz (const PGraph &Graph)
	Returns the fraction of nodes in the largest weakly connected component of a Graph. More...
template<class PGraph >
double	GetMxSccSz (const PGraph &Graph)
	Returns the fraction of nodes in the largest strongly connected component of a Graph. More...
template<class PGraph >
PGraph	GetMxWcc (const PGraph &Graph)
	Returns a graph representing the largest weakly connected component on an input Graph. More...
template<class PGraph >
PGraph	GetMxScc (const PGraph &Graph)
	Returns a graph representing the largest strongly connected component on an input Graph. More...
template<class PGraph >
PGraph	GetMxBiCon (const PGraph &Graph)
	Returns a graph representing the largest bi-connected component on an input Graph. More...
int	LoadModeNetToNet (PMMNet Graph, const TStr &Name, PTable Table, const TStr &NCol, TStrV &NodeAttrV)
	Loads a mode, with name Name, into the PMMNet from the TTable. NCol specifies the node id column and NodeAttrV the node attributes. More...
int	LoadMode (TModeNet &Graph, PTable Table, const TStr &NCol, TStrV &NodeAttrV)
	Loads the nodes specified in column NCol from the TTable with the attributes specified in NodeAttrV. More...
int	LoadCrossNetToNet (PMMNet Graph, const TStr &Mode1, const TStr &Mode2, const TStr &CrossName, PTable Table, const TStr &SrcCol, const TStr &DstCol, TStrV &EdgeAttrV)
	Loads a crossnet from Mode1 to Mode2, with name CrossName, from the provided TTable. EdgeAttrV specifies edge attributes. More...
int	LoadCrossNet (TCrossNet &Graph, PTable Table, const TStr &SrcCol, const TStr &DstCol, TStrV &EdgeAttrV)
	Loads the edges from the TTable and EdgeAttrV specifies columns containing edge attributes. More...
template<class PGraph >
PGraph	ToGraph (PTable Table, const TStr &SrcCol, const TStr &DstCol, TAttrAggr AggrPolicy)
	Sequentially converts the table into a graph with links from nodes in SrcCol to those in DstCol. More...
template<class PGraph >
PGraph	ToNetwork (PTable Table, const TStr &SrcCol, const TStr &DstCol, TStrV &SrcAttrV, TStrV &DstAttrV, TStrV &EdgeAttrV, TAttrAggr AggrPolicy)
	Converts the Table into a graph with edges from SrcCol to DstCol, and attribute vector defined by the arguments. More...
template<class PGraph >
PGraph	ToNetwork (PTable Table, const TStr &SrcCol, const TStr &DstCol, TAttrAggr AggrPolicy)
	Calls ToNetwork with an empty attribute vector. Convenience wrapper. More...
template<class PGraphMP >
PGraphMP	ToGraphMP (PTable Table, const TStr &SrcCol, const TStr &DstCol)
	Performs table to graph conversion in parallel using the sort-first algorithm. This is the recommended method to use. More...
template<class PGraphMP >
PGraphMP	ToGraphMP3 (PTable Table, const TStr &SrcCol, const TStr &DstCol)
	Performs table to graph conversion in parallel. Uses the hash-first method, which is less optimal, use ToGraphMP instead. More...
template<class PGraphMP >
PGraphMP	ToNetworkMP (PTable Table, const TStr &SrcCol, const TStr &DstCol, TStrV &SrcAttrV, TStrV &DstAttrV, TStrV &EdgeAttrV, TAttrAggr AggrPolicy)
	Does Table to Network conversion in parallel using the sort-first algorithm. This is the recommended method to use. More...
template<class PGraphMP >
PGraphMP	ToNetworkMP (PTable Table, const TStr &SrcCol, const TStr &DstCol, TAttrAggr AggrPolicy)
	Calls ToNetworkMP with empty attribute vector. Convenience wrapper. More...
template<class PGraphMP >
PGraphMP	ToNetworkMP2 (PTable Table, const TStr &SrcCol, const TStr &DstCol, TStrV &SrcAttrV, TStrV &DstAttrV, TStrV &EdgeAttrV, TAttrAggr AggrPolicy)
	Implements table to network conversion in parallel. Not the recommended algorithm, using ToNetworkMP instead. More...
template<class PGraphMP >
PGraphMP	ToNetworkMP2 (PTable Table, const TStr &SrcCol, const TStr &DstCol, TAttrAggr AggrPolicy)
	Calls ToNetworkMP2 with an empty attribute vector. Convenience wrapper. More...
template<class PGraph >
PGraph	ToNetwork (PTable Table, const TStr &SrcCol, const TStr &DstCol, TStrV &EdgeAttrV, TAttrAggr AggrPolicy)
	Converts table to a network sequentially. Use if network has only edge attributes. More...
template<class PGraphMP >
PGraphMP	ToNetworkMP (PTable Table, const TStr &SrcCol, const TStr &DstCol, TStrV &EdgeAttrV, TAttrAggr AggrPolicy)
	Converts table to network in parallel. Use if network has only edge attributes. More...
template<class PGraph >
PGraph	ToNetwork (PTable Table, const TStr &SrcCol, const TStr &DstCol, TStrV &EdgeAttrV, PTable NodeTable, const TStr &NodeCol, TStrV &NodeAttrV, TAttrAggr AggrPolicy)
	Converts table to network sequentially. Takes edges from Table and nodes explicitly from NodeCol in NodeTable, with attribute vectors passed as columns in corresponding tables. More...
template<class PGraphMP >
PGraphMP	ToNetworkMP (PTable Table, const TStr &SrcCol, const TStr &DstCol, TStrV &EdgeAttrV, PTable NodeTable, const TStr &NodeCol, TStrV &NodeAttrV, TAttrAggr AggrPolicy)
	Converts table to network in parallel. Takes edges from Table and nodes explicitly from NodeCol in NodeTable, with attribute vectors passed as columns in corresponding tables. More...
int	FastCorePeriphery (PUNGraph &Graph, TIntIntH &out)
int	FastCorePeripheryGC (PUNGraph &Graph, TIntIntH &out)
double	BorgattiEverettMeasure (PUNGraph &Graph, TIntIntH &out, double coresize, int type)
double	PearsonCorrelation (PUNGraph &Graph, TIntIntH &out, int coresize)
int	IntFlowBiDBFS (const PNEANet &Net, const int &CapIndex, TIntV &Flow, TIntQ &FwdNodeQ, TIntH &PredEdgeH, TIntQ &BwdNodeQ, TIntH &SuccEdgeH, const int &SrcNId, const int &SnkNId)
int	FindAugV (const PNEANet &Net, const int &CapIndex, TIntV &Flow, TIntQ &FwdNodeQ, TIntH &PredEdgeH, TIntQ &BwdNodeQ, TIntH &SuccEdgeH, TIntV &MidToSrcAugV, TIntV &MidToSnkAugV, const int &SrcNId, const int &SnkNId)
	Returns the amount the flow can be augmented over the paths, 0 if no path can be found. More...
int	GetMaxFlowIntEK (PNEANet &Net, const int &SrcNId, const int &SnkNId)
	Returns the maximum integer valued flow in the network Net from source SrcNId to sink SnkNId. More...
void	PushToOutNbr (TPRManager &PRM, const int &NId, const int &OutNId, const int &EId)
	Pushes flow from a node NId to a neighbor OutNId over edge EId. More...
void	PushToInNbr (TPRManager &PRM, const int &NId, const int &InNId, const int &EId)
	Returns flow from a node NId to a neighbor InNId over edge EId. More...
void	Relabel (TPRManager &PRM, const int &NId, const TNEANet::TNodeI &NI)
	Increases the label of a node NId to allow valid pushes to some neighbor. More...
int	PushRelabel (TPRManager &PRM, const int &NId, const TNEANet::TNodeI &NI)
	Returns the ID of the neighbor that NId pushes to, -1 if no push was made. More...
void	GlobalRelabel (PNEANet &Net, TPRManager &PRM, const int &SrcNId, const int &SnkNId)
	Implements the Global Relabeling heuristic. More...
int	GetMaxFlowIntPR (PNEANet &Net, const int &SrcNId, const int &SnkNId)
	Returns the maximum integer valued flow in the network Net from source SrcNId to sink SnkNId. More...
TStr	GetFlagStr (const TGraphFlag &GraphFlag)
	Returns a string representation of a flag. More...
template<class PGraph >
void	PrintInfo (const PGraph &Graph, const TStr &Desc="", const TStr &OutFNm="", const bool &Fast=true)
	Prints basic graph statistics. More...
template<class PGraph >
int64	GetTriads (const PGraph &Graph, int64 &ClosedTriadsX, int64 &OpenTriadsX, int SampleNodes)
	Computes the number of Closed and Open triads. More...
template<class PGraph >
int	GetKCoreNodes (const PGraph &Graph, TIntPrV &CoreIdSzV)
	Returns the number of nodes in each core of order K (where K=0, 1, ...) More...
template<class PGraph >
int	GetKCoreEdges (const PGraph &Graph, TIntPrV &CoreIdSzV)
	Returns the number of edges in each core of order K (where K=0, 1, ...) More...
PBPGraph	GenRndBipart (const int &LeftNodes, const int &RightNodes, const int &Edges, TRnd &Rnd=TInt::Rnd)
	Generates a random bipartite graph. More...
PUNGraph	GenRndDegK (const int &Nodes, const int &NodeDeg, const int &NSwitch=100, TRnd &Rnd=TInt::Rnd)
	Generates a random graph where each node has degree exactly NodeDeg. More...
PUNGraph	GenRndPowerLaw (const int &Nodes, const double &PowerExp, const bool &ConfModel=true, TRnd &Rnd=TInt::Rnd)
	Generates a random scale-free graph with power-law degree distribution. More...
PUNGraph	GenDegSeq (const TIntV &DegSeqV, TRnd &Rnd=TInt::Rnd)
	Generates a random graph with exact degree sequence. More...
PUNGraph	GenConfModel (const TIntV &DegSeqV, TRnd &Rnd=TInt::Rnd)
	Generates a random undirect graph with a given degree sequence. More...
PUNGraph	GenRewire (const PUNGraph &Graph, const int &NSwitch=100, TRnd &Rnd=TInt::Rnd)
	Rewire a random undirected graph. Keeps node degrees the same, but randomly rewires the edges. More...
PNGraph	GenRewire (const PNGraph &Graph, const int &NSwitch=100, TRnd &Rnd=TInt::Rnd)
	Rewire a random directed graph. Keeps node degrees the same, but randomly rewires the edges. More...
PBPGraph	GenRewire (const PBPGraph &Graph, const int &NSwitch=100, TRnd &Rnd=TInt::Rnd)
	Rewire a random bipartite graph. Keeps node degrees the same, but randomly rewires the edges. More...
PUNGraph	GenPrefAttach (const int &Nodes, const int &NodeOutDeg, TRnd &Rnd=TInt::Rnd)
	Generates a power-law degree distribution using Barabasi-Albert model of scale-free graphs. More...
PUNGraph	GenConfModel (const PUNGraph &G)
	Generate a random graph using (approximately) the same node degrees as in G using the configuration model. More...
PUNGraph	GenGeoPrefAttach (const int &Nodes, const int &OutDeg, const double &Beta, TRnd &Rnd=TInt::Rnd)
	Generates a random scale-free graph using the Geometric Preferential model. More...
PUNGraph	GenSmallWorld (const int &Nodes, const int &NodeOutDeg, const double &RewireProb, TRnd &Rnd=TInt::Rnd)
	Generates a randomly small-world graph using the Watts-Strogatz model. More...
PNGraph	GenForestFire (const int &Nodes, const double &FwdProb, const double &BckProb)
	Generates a random Forest Fire, directed graph with given probabilities. More...
PNGraph	GenCopyModel (const int &Nodes, const double &Beta, TRnd &Rnd=TInt::Rnd)
	Generates a random scale-free network using the Copying Model. More...
PNGraph	GenRMat (const int &Nodes, const int &Edges, const double &A, const double &B, const double &C, TRnd &Rnd=TInt::Rnd)
	Generates a R-MAT graph using recursive descent into a 2x2 matrix [A,B; C, 1-(A+B+C)]. More...
PNGraph	GenRMatEpinions ()
	Generates a R-Mat graph, with a synthetic copy of the Epinions social network. More...
template<class PGraph >
PGraph	GenGrid (const int &Rows, const int &Cols, const bool &IsDir=true)
	Generates a 2D-grid graph of Rows rows and Cols columns. More...
template<class PGraph >
PGraph	GenStar (const int &Nodes, const bool &IsDir=true)
	Generates a graph with star topology. Node id 0 is in the center and then links to all other nodes. More...
template<class PGraph >
PGraph	GenCircle (const int &Nodes, const int &NodeOutDeg=1, const bool &IsDir=true)
	Generates a circle graph where every node creates out-links to NodeOutDeg forward nodes. More...
template<class PGraph >
PGraph	GenFull (const int &Nodes)
	Generates a complete graph on Nodes nodes. Graph has no self-loops. More...
template<class PGraph >
PGraph	GenTree (const int &Fanout, const int &Levels, const bool &IsDir=true, const bool &ChildPointsToParent=true)
	Generates a tree graph of Levels levels with every parent having Fanout children. More...
template<class PGraph >
PGraph	GenBaraHierar (const int &Levels, const bool &IsDir=true)
	Generates a Ravasz-Barabasi deterministic scale-free graph. More...
template<class PGraph >
PGraph	GenRndGnm (const int &Nodes, const int &Edges, const bool &IsDir=true, TRnd &Rnd=TInt::Rnd)
	Generates an Erdos-Renyi random graph. More...
int	ReadEdgeSchemaFromFile (TSsParser &Ss, const char &Separator, int &SrcColId, int &DstColId, TStrIntH &IntAttrEVals, TStrIntH &FltAttrEVals, TStrIntH &StrAttrEVals)
bool	ReadEdgesFromFile (TSsParser &Ss, const char &Separator, PNEANet &Graph, int &SrcColId, int &DstColId, TStrIntH &IntAttrEVals, TStrIntH &FltAttrEVals, TStrIntH &StrAttrEVals)
int	ReadNodeSchemaFromFile (TSsParser &Ss, const char &Separator, int &NId, TStrIntH &IntAttrNVals, TStrIntH &FltAttrNVals, TStrIntH &StrAttrNVals)
bool	ReadNodesFromFile (TSsParser &Ss, const char &Separator, PNEANet &Graph, int &NColId, TStrIntH &IntAttrNVals, TStrIntH &FltAttrNVals, TStrIntH &StrAttrNVals)
PNEANet	LoadEdgeListNet (const TStr &InFNm, const char &Separator)
	Loads a network from the text file InFNm with 1 node/edge per line ('Separator' separated columns, integer node id(s) + node/edge attributes). More...
void	WriteNodeSchemaToFile (FILE *F, TStrV &IntAttrNNames, TStrV &FltAttrNNames, TStrV &StrAttrNNames)
void	WriteNodesToFile (FILE *F, const PNEANet &Graph, TStrV &IntAttrNNames, TStrV &FltAttrNNames, TStrV &StrAttrNNames)
void	WriteEdgeSchemaToFile (FILE *F, TStrV &IntAttrENames, TStrV &FltAttrENames, TStrV &StrAttrENames)
void	WriteEdgesToFile (FILE *F, const PNEANet &Graph, TStrV &IntAttrENames, TStrV &FltAttrENames, TStrV &StrAttrENames)
void	SaveEdgeListNet (const PNEANet &Graph, const TStr &OutFNm, const TStr &Desc)
	Saves a network into a text file. Each line encodes either an edge or a node, along with its attributes. More...
PNGraph	LoadDyNet (const TStr &FNm)
	For more info see ORA Network Analysis Data (http://www.casos.cs.cmu.edu/computational_tools/data2.php) More...
TVec< PNGraph >	LoadDyNetGraphV (const TStr &FNm)
	For more info see ORA Network Analysis Data (http://www.casos.cs.cmu.edu/computational_tools/data2.php) More...
template<class PGraph >
PGraph	LoadEdgeList (const TStr &InFNm, const int &SrcColId=0, const int &DstColId=1)
	Loads a (directed, undirected or multi) graph from a text file InFNm with 1 edge per line (whitespace separated columns, integer node ids). More...
template<class PGraph >
PGraph	LoadEdgeList (const TStr &InFNm, const int &SrcColId, const int &DstColId, const char &Separator)
	Loads a (directed, undirected or multi) graph from a text file InFNm with 1 edge per line ('Separator' separated columns, integer node ids). More...
template<class PGraph >
PGraph	LoadEdgeListStr (const TStr &InFNm, const int &SrcColId=0, const int &DstColId=1)
	Loads a (directed, undirected or multi) graph from a text file InFNm with 1 edge per line (whitespace separated columns, arbitrary string node ids). More...
template<class PGraph >
PGraph	LoadEdgeListStr (const TStr &InFNm, const int &SrcColId, const int &DstColId, TStrHash< TInt > &StrToNIdH)
	Loads a (directed, undirected or multi) graph from a text file InFNm with 1 edge per line (whitespace separated columns, arbitrary string node ids). More...
template<class PGraph >
PGraph	LoadConnList (const TStr &InFNm)
	Loads a (directed, undirected or multi) graph from a text file InFNm with 1 node and all its edges in a single line. More...
template<class PGraph >
PGraph	LoadConnListStr (const TStr &InFNm, TStrHash< TInt > &StrToNIdH)
	Loads a (directed, undirected or multi) graph from a text file InFNm with 1 node and all its edges in a single line. More...
template<class PGraph >
PGraph	LoadPajek (const TStr &InFNm)
	Loads a (directed, undirected or multi) graph from Pajek .PAJ format file. More...
template<class PGraph >
void	SaveEdgeList (const PGraph &Graph, const TStr &OutFNm, const TStr &Desc=TStr())
	Saves a graph into a text file. Each line contains two columns and encodes a single edge: <source node="" id>=""><tab><destination node="" id>=""> More...
template<class PGraph >
void	SavePajek (const PGraph &Graph, const TStr &OutFNm)
	Saves a graph in a Pajek .NET format. More...
template<class PGraph >
void	SavePajek (const PGraph &Graph, const TStr &OutFNm, const TIntStrH &NIdColorH)
	Saves a graph in a Pajek .NET format. More...
template<class PGraph >
void	SavePajek (const PGraph &Graph, const TStr &OutFNm, const TIntStrH &NIdColorH, const TIntStrH &NIdLabelH)
	Saves a graph in a Pajek .NET format. More...
template<class PGraph >
void	SavePajek (const PGraph &Graph, const TStr &OutFNm, const TIntStrH &NIdColorH, const TIntStrH &NIdLabelH, const TIntStrH &EIdColorH)
	Saves a graph in a Pajek .NET format. More...
template<class PGraph >
void	SaveMatlabSparseMtx (const PGraph &Graph, const TStr &OutFNm)
	Saves a graph in a MATLAB sparse matrix format. More...
template<class PGraph >
void	SaveGViz (const PGraph &Graph, const TStr &OutFNm, const TStr &Desc=TStr(), const bool &NodeLabels=false, const TIntStrH &NIdColorH=TIntStrH())
	Save a graph in GraphVizp .DOT format. More...
template<class PGraph >
void	SaveGViz (const PGraph &Graph, const TStr &OutFNm, const TStr &Desc, const TIntStrH &NIdLabelH)
	Save a graph in GraphVizp .DOT format. More...
void	SetAllInvertSign (TFltV &ValV, const double &Val)
bool	IsAllValVNeg (TFltV &ValV, const bool &InvertSign)
void	GetSngVals (const PNGraph &Graph, const int &SngVals, TFltV &SngValV)
	Computes largest SngVals singular values of the adjacency matrix representing a directed Graph. More...
void	GetSngVec (const PNGraph &Graph, TFltV &LeftSV, TFltV &RightSV)
	Computes the leading left and right singular vector of the adjacency matrix representing a directed Graph. More...
void	GetSngVec (const PNGraph &Graph, const int &SngVecs, TFltV &SngValV, TFltVFltV &LeftSV, TFltVFltV &RightSV)
void	GetEigVals (const PUNGraph &Graph, const int &EigVals, TFltV &EigValV)
	Computes top EigVals eigenvalues of the adjacency matrix representing a given undirected Graph. More...
void	GetEigVec (const PUNGraph &Graph, TFltV &EigVecV)
	Computes the leading eigenvector of the adjacency matrix representing a given undirected Graph. More...
void	GetEigVec (const PUNGraph &Graph, const int &EigVecs, TFltV &EigValV, TFltVFltV &EigVecV)
	Computes top EigVecs eigenvalues and eigenvectors of the adjacency matrix representing a given undirected Graph. More...
void	GetInvParticipRat (const PUNGraph &Graph, int MaxEigVecs, int TimeLimit, TFltPrV &EigValIprV)
template<class PGraph >
void	DrawGViz (const PGraph &Graph, const TGVizLayout &Layout, const TStr &PltFNm, const TStr &Desc=TStr(), const bool &NodeLabels=false, const TIntStrH &NIdColorH=TIntStrH())
	Draws a given Graph using a selected GraphViz Layout engine with nodes colored. More...
template<class PGraph >
void	DrawGViz (const PGraph &Graph, const TGVizLayout &Layout, const TStr &PltFNm, const TStr &Desc, const TIntStrH &NodeLabelH)
	Draws a given Graph using a selected GraphViz Layout engine with nodes labeled. More...
template<class PGraph >
PGraph	GetKCore (const PGraph &Graph, const int &K)
void	TIntVToNumpy (TIntV &IntV, int *IntNumpyVecOut, int n)
	Converts TIntV to Numpy array. More...
void	TFltVToNumpy (TFltV &FltV, float *FltNumpyVecOut, int n)
	Converts TFltV to Numpy array. More...
void	NumpyToTIntV (TIntV &IntV, int *IntNumpyVecIn, int n)
	Converts NumpyArray to TIntV. More...
void	NumpyToTFltV (TFltV &FltV, float *FltNumpyVecIn, int n)
	Converts NumpyArray to TFltV. More...
template<class PGraph >
int	SamplePersonalizedPageRank (const PGraph &Graph, double JumpProb, const TIntV &StartNIdV, TRnd &Rnd)
template<class PGraph >
double	GetPersonalizedPageRankBidirectional (const PGraph &Graph, double JumpProb, const TIntV &StartNIdV, int TargetNId, double MinProbability=-1.0, double RelativeError=0.1, bool provableRelativeError=false, bool PrintTimeForTuning=false)
template<class PGraph >
double	GetRndWalkRestartBidirectional (const PGraph &Graph, double JumpProb, int StartNId, int TargetNId, double minProbability=-1.0, double relativeError=0.1, bool proveRelativeError=false, bool PrintTimeForTuning=false)
void	PlotEigValRank (const PUNGraph &Graph, const int &EigVals, const TStr &FNmPref, TStr DescStr=TStr())
	Plots the eigen-value rank distribution of the Graph adjacency matrix. Plots first EigVals eigenvalues. More...
void	PlotEigValDistr (const PUNGraph &Graph, const int &EigVals, const TStr &FNmPref, TStr DescStr=TStr())
	Plots the distribution of components of the leading eigen-vector of the Graph adjacency matrix. Plots first EigVals values. More...
void	PlotInvParticipRat (const PUNGraph &Graph, const int &MaxEigVecs, const int &TimeLimit, const TStr &FNmPref, TStr DescStr)
void	PlotSngValRank (const PNGraph &Graph, const int &SngVals, const TStr &FNmPref, TStr DescStr=TStr())
	Plots the rank distribution of singular values of the Graph adjacency matrix. Plots first SngVals values. More...
void	PlotSngValDistr (const PNGraph &Graph, const int &SngVals, const TStr &FNmPref, TStr DescStr=TStr())
	Plots the rank distribution of singular values of the Graph adjacency matrix. Plots first SngVals values. More...
void	PlotSngVec (const PNGraph &Graph, const TStr &FNmPref, TStr DescStr=TStr())
	Plots the distribution of the values of the leading left singular vector of the Graph adjacency matrix. Plots first SngVals values. More...
template<class PGraph >
void	PlotInDegDistr (const PGraph &Graph, const TStr &FNmPref, TStr DescStr=TStr(), const bool &PlotCCdf=false, const bool &PowerFit=false)
template<class PGraph >
void	PlotOutDegDistr (const PGraph &Graph, const TStr &FNmPref, TStr DescStr=TStr(), const bool &PlotCCdf=false, const bool &PowerFit=false)
template<class PGraph >
void	PlotWccDistr (const PGraph &Graph, const TStr &FNmPref, TStr DescStr=TStr())
	Plots the distribution of sizes of weakly connected components of a Graph. More...
template<class PGraph >
void	PlotSccDistr (const PGraph &Graph, const TStr &FNmPref, TStr DescStr=TStr())
	Plots the distribution of sizes of strongly connected components of a Graph. More...
template<class PGraph >
void	PlotClustCf (const PGraph &Graph, const TStr &FNmPref, TStr DescStr=TStr())
	Plots the distribution of clustering coefficient of a Graph. More...
template<class PGraph >
void	PlotHops (const PGraph &Graph, const TStr &FNmPref, TStr DescStr=TStr(), const bool &IsDir=false, const int &NApprox=32)
template<class PGraph >
void	PlotShortPathDistr (const PGraph &Graph, const TStr &FNmPref, TStr DescStr=TStr(), int TestNodes=TInt::Mx)
	Plots the distribution of the shortest path lengths of a Graph. Implementation is based on BFS. More...
template<class PGraph >
void	PlotKCoreNodes (const PGraph &Graph, const TStr &FNmPref, TStr DescStr=TStr())
	Plots the k-Core node-size distribution: Core k vs. number of nodes in k-core. More...
template<class PGraph >
void	PlotKCoreEdges (const PGraph &Graph, const TStr &FNmPref, TStr DescStr=TStr())
	Plots the k-Core edge-size distribution: Core k vs. number of edges in k-core. More...
PUNGraph	GetSubGraph (const PUNGraph &Graph, const TIntV &NIdV, const bool &RenumberNodes=false)
	Returns an induced subgraph of an undirected graph Graph with NIdV nodes with an optional node renumbering. More...
PNGraph	GetSubGraph (const PNGraph &Graph, const TIntV &NIdV, const bool &RenumberNodes)
PUNGraph	GetEgonet (const PUNGraph &Graph, const int CtrNId, int &ArndEdgesX)
	Returns the egonet of node CtrNId as center in undirected graph Graph. And returns number of edges around the egonet. More...
PNGraph	GetEgonet (const PNGraph &Graph, const int CtrNId, int &InEgoEdgesX, int &OutEgoEdgesX)
	Returns the egonet of node CtrNId as center in directed graph Graph. And returns number of edges go in and out the egonet. More...
void	AddNodeWithAttributes (const PNEANet &Graph1, PNEANet &Graph2, const int NId)
void	AddEdgeWithAttributes (const PNEANet &Graph1, PNEANet &Graph2, const int EId)
void	AddEdgeWithAttributes (const PNEANet &Graph1, PNEANet &Graph2, const int NId, const int NbrId)
PNEANet	GetEgonetAttr (const PNEANet &Graph, const int CtrNId, const int Radius)
	Returns the complete egonet of at given radius and copies node and edge attributes. More...
PNEANet	GetInEgonetAttr (const PNEANet &Graph, const int CtrNId, const int Radius)
	Returns the in-egonet of at given radius and copies node and edge attributes. More...
PNEANet	GetOutEgonetAttr (const PNEANet &Graph, const int CtrNId, const int Radius)
	Returns the out-egonet of at given radius and copies node and edge attributes. More...
PNEANet	GetInEgonetSubAttr (const PNEANet &Graph, const int CtrNId, const int Radius, const int MaxNum, const float percent)
	Returns the randomly sampled egonet with nodes sampled based on percentage or raw number, copying attributes. More...
PNEANet	GetGraphUnionAttr (PNEANet &DstGraph, const PNEANet &SrcGraph)
template<class PGraph >
PGraph	GetSubGraph (const PGraph &Graph, const TIntV &NIdV)
	Returns an induced subgraph of graph Graph with NIdV nodes. More...
template<class PGraph >
PGraph	GetSubGraphRenumber (const PGraph &Graph, const TIntV &NIdV)
	Returns an induced subgraph of graph Graph with NIdV nodes with an node renumbering. More...
template<class PGraph >
PGraph	GetESubGraph (const PGraph &Graph, const TIntV &EIdV)
	Returns a subgraph of graph Graph with EIdV edges. More...
template<class PGraph >
PGraph	GetESubGraph (const PGraph &Graph, const TIntPrV &EdgeV)
template<class PGraph , class TEdgeDat >
PGraph	GetEDatSubGraph (const PGraph &Graph, const TEdgeDat &EDat, const int &Cmp)
	Returns a subgraph of graph Graph with edges where edge data matches the parameters. More...
template<class PGraph , class TEdgeDat >
PGraph	GetEDatSubGraph (const PGraph &Graph, const TIntV &NIdV, const TEdgeDat &EDat, const int &Cmp)
	Returns a subgraph of graph Graph with NIdV nodes and edges where edge data matches the parameters. More...
template<class POutGraph , class PInGraph >
POutGraph	ConvertGraph (const PInGraph &InGraph, const bool &RenumberNodes=false)
	Performs conversion of graph InGraph with an optional node renumbering. More...
template<class POutGraph , class PInGraph >
POutGraph	ConvertSubGraph (const PInGraph &InGraph, const TIntV &NIdV, const bool &RenumberNodes=false)
	Returns an induced subgraph of graph InGraph with NIdV nodes with an optional node renumbering. More...
template<class POutGraph , class PInGraph >
POutGraph	ConvertESubGraph (const PInGraph &InGraph, const TIntV &EIdV, const bool &RenumberNodes=false)
	Returns a subgraph of graph InGraph with EIdV edges with an optional node renumbering. More...
template<class PGraph >
PGraph	GetRndSubGraph (const PGraph &Graph, const int &NNodes)
	Returns an induced random subgraph of graph Graph with NNodes nodes. More...
template<class PGraph >
PGraph	GetRndESubGraph (const PGraph &Graph, const int &NEdges)
	Returns a random subgraph of graph Graph with NEdges edges. More...
template<class PGraph >
PGraph	GetEgonetHop (const PGraph &Graph, const int CtrNId, const int Radius)
	Returns the egonet of node CtrNId as center for a Graph for a given radius. More...
template<class PGraph >
PGraph	GetInEgonetHop (const PGraph &Graph, const int CtrNId, const int Radius)
	Returns the in-egonet of node CtrNId as center in directed graph Graph for a given radius. More...
template<class PGraph >
PGraph	GetOutEgonetHop (const PGraph &Graph, const int CtrNId, const int Radius)
	Returns the out-egonet of node CtrNId as center in directed graph Graph for a given radius. More...
template<class PGraph >
PGraph	GetInEgonetSub (const PGraph &Graph, const int CtrNId, const int Radius, const int MaxNum=2, const float percent=-1.0)
	Returns the randomly sampled in-egonet with nodes sampled based on percentage, if percent != -1.0, or MaxNum nodes otherwise. More...
template<class PGraph >
PGraph	GetGraphUnion (PGraph &DstGraph, const PGraph &SrcGraph)
int	GetCommon (TIntV &A, TIntV &B)
	Returns the number of common elements in two sorted TInt vectors. More...
template<class PGraph >
double	GetClustCf (const PGraph &Graph, int SampleNodes=-1)
	Computes the average clustering coefficient as defined in Watts and Strogatz, Collective dynamics of 'small-world' networks. More...
template<class PGraph >
double	GetClustCf (const PGraph &Graph, TFltPrV &DegToCCfV, int SampleNodes=-1)
	Computes the distribution of average clustering coefficient. More...
template<class PGraph >
double	GetClustCf (const PGraph &Graph, TFltPrV &DegToCCfV, int64 &ClosedTriads, int64 &OpenTriads, int SampleNodes=-1)
	Computes the distribution of average clustering coefficient as well as the number of open and closed triads in the graph. More...
template<class PGraph >
double	GetClustCfAll (const PGraph &Graph, TFltPrV &DegToCCfV, int64 &ClosedTriadsX, int64 &OpenTriadsX, int SampleNodes=-1)
	Computes the distribution of average clustering coefficient as well as the number of open and closed triads in the graph. More...
template<class PGraph >
double	GetNodeClustCf (const PGraph &Graph, const int &NId)
	Returns clustering coefficient of a particular node. More...
template<class PGraph >
void	GetNodeClustCf (const PGraph &Graph, TIntFltH &NIdCCfH)
	Computes clustering coefficient of each node of the Graph. More...
template<class PGraph >
int64	GetTriads (const PGraph &Graph, int SampleNodes=-1)
	Returns the number of triangles in a graph. More...
template<class PGraph >
int64	GetTriadsAll (const PGraph &Graph, int64 &ClosedTriadsX, int64 &OpenTriadsX, int SampleNodes=-1)
	Computes the number of Closed and Open triads. More...
template<class PGraph >
void	GetTriads (const PGraph &Graph, TIntTrV &NIdCOTriadV, int SampleNodes=-1)
	Computes the number of open and close triads for every node of the network. More...
template<class PGraph >
int	GetTriadEdges (const PGraph &Graph, int SampleEdges=-1)
	Counts the number of edges that participate in at least one triad. More...
template<class PGraph >
int	GetNodeTriads (const PGraph &Graph, const int &NId)
	Returns the number of undirected triads a node NId participates in. More...
template<class PGraph >
int	GetNodeTriads (const PGraph &Graph, const int &NId, int &ClosedNTriadsX, int &OpenNTriadsX)
	Returns number of Open and Closed triads a node NId participates in. More...
template<class PGraph >
int	GetNodeTriadsAll (const PGraph &Graph, const int &NId, int &ClosedNTriadsX, int &OpenNTriadsX)
	Returns number of Open and Closed triads a node NId participates in. More...
template<class PGraph >
int	GetNodeTriads (const PGraph &Graph, const int &NId, const TIntSet &GroupSet, int &InGroupEdgesX, int &InOutGroupEdgesX, int &OutGroupEdgesX)
	Returns the number of triads between a node NId and a subset of its neighbors GroupSet. More...
template<class PGraph >
void	GetTriadParticip (const PGraph &Graph, TIntPrV &TriadCntV)
	Triangle Participation Ratio: For each node counts how many triangles it participates in and then returns a set of pairs (number of triangles, number of such nodes). More...
template<class PGraph >
int	GetCmnNbrs (const PGraph &Graph, const int &NId1, const int &NId2)
	Returns a number of shared neighbors between a pair of nodes NId1 and NId2. More...
template<class PGraph >
int	GetCmnNbrs (const PGraph &Graph, const int &NId1, const int &NId2, TIntV &NbrV)
	Returns the shared neighbors between a pair of nodes NId1 and NId2. More...
template<class PGraph >
int	GetLen2Paths (const PGraph &Graph, const int &NId1, const int &NId2)
	Returns the number of length 2 directed paths between a pair of nodes NId1, NId2 (NId1 –> U –> NId2). More...
template<class PGraph >
int	GetLen2Paths (const PGraph &Graph, const int &NId1, const int &NId2, TIntV &NbrV)
	Returns the 2 directed paths between a pair of nodes NId1, NId2 (NId1 –> U –> NId2). More...
template<class PGraph >
int64	GetTriangleCnt (const PGraph &Graph)
	Returns the number of triangles in graph Graph. More...
template<class PGraph >
void	MergeNbrs (TIntV &NeighbourV, const typename PGraph::TObj::TNodeI &NI)
	Merges neighbors by removing duplicates and produces one sorted vector of neighbors. More...
template<class PGraph >
void	GetUniqueNbrV (const PGraph &Graph, const int &NId, TIntV &NbrV)
	Returns sorted vector NbrV containing unique in or out neighbors of node NId in graph Graph. More...
template<class PGraph >
void	GetTriads_v0 (const PGraph &Graph, TIntTrV &NIdCOTriadV, int SampleNodes)
template<>
int	GetCmnNbrs< PUNGraph > (const PUNGraph &Graph, const int &NId1, const int &NId2, TIntV &NbrV)

Variables
const TStr	CapAttrName = "capacity"
const TStr	EDGES_START = ("#EDGES")
const TStr	NODES_START = ("#NODES")
const TStr	END_SENTINEL = ("#END")
const TStr	SRC_ID_NAME = ("SrcNId")
const TStr	DST_ID_NAME = ("DstNId")
const TStr	NID_NAME = ("NId")
const TStr	INT_TYPE_PREFIX = ("Int")
const TStr	FLT_TYPE_PREFIX = ("Flt")
const TStr	STR_TYPE_PREFIX = ("Str")
const TStr	NULL_VAL = ("__null__")

Detailed Description

Main namespace for all the Snap global entities.

The name of the friend is not found by simple name lookup until a matching declaration is provided in that namespace scope (either before or after the class declaration granting friendship).

Function Documentation

void TSnap::AddEdgeWithAttributes	(	const PNEANet &	Graph1,
		PNEANet &	Graph2,
		const int	EId
	)

Definition at line 179 of file subgraph.cpp.

                                                                                 {
  const TNEANet::TEdgeI EI = Graph1->GetEI(EId);
  Graph2->AddEdge(EI);
  //const int EId = Graph2->GetEId(NId, NbrId);
  // Copy Int Attributes
  TStrV IntAttrNames;
  TIntV IntAttrValues;
  Graph1->IntAttrNameEI(EId, IntAttrNames);
  Graph1->IntAttrValueEI(EId, IntAttrValues);
  for (int i = 0; i < IntAttrNames.Len(); i++) {
    Graph2->AddIntAttrDatE(EId, IntAttrValues[i], IntAttrNames[i]);
  }
  // Copy Float Attributes
  TStrV FltAttrNames;
  TFltV FltAttrValues;
  Graph1->FltAttrNameEI(EId, FltAttrNames);
  Graph1->FltAttrValueEI(EId, FltAttrValues);
  for (int i = 0; i < FltAttrNames.Len(); i++) {
    Graph2->AddFltAttrDatE(EId, FltAttrValues[i], FltAttrNames[i]);
  }
  // Copy Str Attributes
  TStrV StrAttrNames;
  TStrV StrAttrValues;
  Graph1->StrAttrNameEI(EId, StrAttrNames);
  Graph1->StrAttrValueEI(EId, StrAttrValues);
  for (int i = 0; i < StrAttrNames.Len(); i++) {
    Graph2->AddStrAttrDatE(EId, StrAttrValues[i], StrAttrNames[i]);
  }
  // Copy IntV Attributes
  TStrV IntVAttrNames;
  TVec<TIntV> IntVAttrValues;
  Graph1->IntVAttrNameEI(EId, IntVAttrNames);
  Graph1->IntVAttrValueEI(EId, IntVAttrValues);
  for (int i = 0; i < IntVAttrNames.Len(); i++) {
    Graph2->AddIntVAttrDatE(EId, IntVAttrValues[i], IntVAttrNames[i]);
  }
}

void TSnap::AddEdgeWithAttributes	(	const PNEANet &	Graph1,
		PNEANet &	Graph2,
		const int	NId,
		const int	NbrId
	)

Definition at line 217 of file subgraph.cpp.

                                                                                                   {
  Graph2->AddEdge(NId, NbrId);
  const int EId = Graph2->GetEId(NId, NbrId);
  // Copy Int Attributes
  TStrV IntAttrNames;
  TIntV IntAttrValues;
  Graph1->IntAttrNameEI(EId, IntAttrNames);
  Graph1->IntAttrValueEI(EId, IntAttrValues);
  for (int i = 0; i < IntAttrNames.Len(); i++) {
    Graph2->AddIntAttrDatE(EId, IntAttrValues[i], IntAttrNames[i]);
  }
  // Copy Float Attributes
  TStrV FltAttrNames;
  TFltV FltAttrValues;
  Graph1->FltAttrNameEI(EId, FltAttrNames);
  Graph1->FltAttrValueEI(EId, FltAttrValues);
  for (int i = 0; i < FltAttrNames.Len(); i++) {
    Graph2->AddFltAttrDatE(EId, FltAttrValues[i], FltAttrNames[i]);
  }
  // Copy Str Attributes
  TStrV StrAttrNames;
  TStrV StrAttrValues;
  Graph1->StrAttrNameEI(EId, StrAttrNames);
  Graph1->StrAttrValueEI(EId, StrAttrValues);
  for (int i = 0; i < StrAttrNames.Len(); i++) {
    Graph2->AddStrAttrDatE(EId, StrAttrValues[i], StrAttrNames[i]);
  }
  // Copy IntV Attributes
  TStrV IntVAttrNames;
  TVec<TIntV> IntVAttrValues;
  Graph1->IntVAttrNameEI(EId, IntVAttrNames);
  Graph1->IntVAttrValueEI(EId, IntVAttrValues);
  for (int i = 0; i < IntVAttrNames.Len(); i++) {
    Graph2->AddIntVAttrDatE(EId, IntVAttrValues[i], IntVAttrNames[i]);
  }
}

void TSnap::AddNodeWithAttributes	(	const PNEANet &	Graph1,
		PNEANet &	Graph2,
		const int	NId
	)

Definition at line 143 of file subgraph.cpp.

                                                                                  {
  Graph2->AddNode(NId);
  // Copy Int Attributes
  TStrV IntAttrNames;
  TIntV IntAttrValues;
  Graph1->IntAttrNameNI(NId, IntAttrNames);
  Graph1->IntAttrValueNI(NId, IntAttrValues);
  for (int i = 0; i < IntAttrNames.Len(); i++) {
    Graph2->AddIntAttrDatN(NId, IntAttrValues[i], IntAttrNames[i]);
  }
  // Copy Float Attributes
  TStrV FltAttrNames;
  TFltV FltAttrValues;
  Graph1->FltAttrNameNI(NId, FltAttrNames);
  Graph1->FltAttrValueNI(NId, FltAttrValues);
  for (int i = 0; i < FltAttrNames.Len(); i++) {
    Graph2->AddFltAttrDatN(NId, FltAttrValues[i], FltAttrNames[i]);
  }
  // Copy Str Attributes
  TStrV StrAttrNames;
  TStrV StrAttrValues;
  Graph1->StrAttrNameNI(NId, StrAttrNames);
  Graph1->StrAttrValueNI(NId, StrAttrValues);
  for (int i = 0; i < StrAttrNames.Len(); i++) {
    Graph2->AddStrAttrDatN(NId, StrAttrValues[i], StrAttrNames[i]);
  }
  // Copy IntV Attributes
  TStrV IntVAttrNames;
  TVec<TIntV> IntVAttrValues;
  Graph1->IntVAttrNameNI(NId, IntVAttrNames);
  Graph1->IntVAttrValueNI(NId, IntVAttrValues);
  for (int i = 0; i < IntVAttrNames.Len(); i++) {
    Graph2->AddIntVAttrDatN(NId, IntVAttrValues[i], IntVAttrNames[i]);
  }
}

template<class PGraph >

void TSnap::AddSelfEdges

(

const PGraph &

Graph

)

Adds a self-edge to every node in the graph.

Definition at line 369 of file alg.h.

                                       {
  TIntV EdgeV;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    const int NId = NI.GetId();
    if (! Graph->IsEdge(NId, NId)) {
      EdgeV.Add(NId);
    }
  }
  for (int i = 0; i < EdgeV.Len(); i++) {
    Graph->AddEdge(EdgeV[i], EdgeV[i]);
  }
}

TIntH* TSnap::AllCombinationsMN	(	int	m,
		int	n
	)

Definition at line 157 of file centr.cpp.

                                      {
  float N = 1;
  for(int i=n; i>0; i--){
    N *= (float)m/(float)n;
    m--;
  n--;
  }

  TIntH* C = new TIntH[(int)N];
  return C;
}

PUNGraph* TSnap::AllGraphsWithNNodes

(

int

n

)

Definition at line 138 of file centr.cpp.

                                    {
  PUNGraph* g = new PUNGraph[(((n*n)-n)/2)+1];
  PUNGraph g0;
  for(int i=0; i<n; i++)
    g0->AddNode(i);
  
  g[0] = g0;
  int br=1;

  for(int i=0; i<n; i++)
  for(int j=i; j<n; j++){
      g0->AddEdge(i,j);
    g[br] = g0;
    br++;
  }

  return g;
}

double TSnap::BorgattiEverettMeasure	(	PUNGraph &	Graph,
		TIntIntH &	out,
		double	coresize,
		int	type
	)

Definition at line 186 of file coreper.cpp.

                                                                                          {
    
    double sum = 0.0;
    for (TUNGraph::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++){ // Calculate and store the degrees of each node.
      int i = EI.GetSrcNId();
      int j = EI.GetDstNId();
      if (type == 1) {
        if (out.GetDat(i) == 1 || out.GetDat(j) == 1)
          sum += 1;
      }
      else {
        if (out.GetDat(i) == 1 && out.GetDat(j) == 1)
          sum += 1;
      }
    }

    return sum/(((coresize*coresize)-coresize)/2);
  }

void TSnap::CascFind	(	PNGraph	Graph,
		PTable	P,
		const TStr	C1,
		const TStr	C2,
		const TStr	C3,
		const TStr	C4,
		TVec< TIntV > &	TopCascVV,
		bool	Print
	)

Takes as input a directed graph and returns all the top cascades in TopCascVV.

Definition at line 135 of file casc.cpp.

                                                                                                                                {
  // Attribute to Int mapping
  TInt SIdx = P->GetColIdx(C1);
  TInt DIdx = P->GetColIdx(C2);
  TInt StIdx = P->GetColIdx(C3);
  TInt DuIdx = P->GetColIdx(C4);
  TIntV MapV, PhyV;
  TStrV SortBy;
  SortBy.Add(C3);
  P->Order(SortBy);
  int count = 0;
  for (TRowIterator RI = P->BegRI(); RI < P-> EndRI(); RI++) {
    MapV.Add(RI.GetRowIdx());
    PhyV.Add(count++);
  }
  // After sort attach with each row a rank helpful for sorting
  P->StoreIntCol("Physical",PhyV);
  TInt PIdx = P->GetColIdx("Physical");
  for (TNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    // Check for top cascades
    if (NI.GetInDeg() != 0) { continue;}
    TIntV CurCasc;
    TSnapQueue<TInt> EventQ;
    THashSet<TInt> VisitedH;
    TInt NId = NI.GetId();
    EventQ.Push(NId);
    VisitedH.AddKey(NId);
    CurCasc.Add(P->GetIntValAtRowIdx(PIdx,NId));
    while (! EventQ.Empty()) {
      TNGraph::TNodeI CNI = Graph->GetNI(EventQ.Top().Val); //Get Current Node
      EventQ.Pop();
      // Go over the outdegree nodes of the currernt node
      for (int e = 0; e < CNI.GetOutDeg(); e++) {
        TInt CId = CNI.GetOutNId(e);
        if ( !VisitedH.IsKey(CId)) {
          EventQ.Push(CId);
          VisitedH.AddKey(CId);
          CurCasc.Add(P->GetIntValAtRowIdx(PIdx,CId));
        }
      }
    }
    CurCasc.Sort();
    TIntV ToAddV;
    if (Print && VisitedH.Len() > 1) {
      printf("__casacade__\t%d\n",VisitedH.Len());
    }
    for (TIntV::TIter VI = CurCasc.BegI(); VI < CurCasc.EndI(); VI++) {
      ToAddV.Add(MapV.GetVal(VI->Val));
      if (Print && VisitedH.Len() > 1) {
        int PIdx = MapV.GetVal(VI->Val).Val;
        int PSource = P->GetIntValAtRowIdx(SIdx,PIdx).Val;
        int PDest = P->GetIntValAtRowIdx(DIdx,PIdx).Val;
        int PStart = P->GetIntValAtRowIdx(StIdx,PIdx).Val;    
        int PDur = P->GetIntValAtRowIdx(DuIdx,PIdx).Val;
        printf("%d\t%d\t%d\t%d\t%d\n",PIdx,PSource,PDest,PStart,PDur);
      }   
    }
    if (ToAddV.Len() > 1) {
      TopCascVV.Add(ToAddV);
    }
  }
  return;
}

void TSnap::CascFindMP	(	PNGraph	Graph,
		PTable	P,
		const TStr	C1,
		const TStr	C2,
		const TStr	C3,
		const TStr	C4,
		TVec< TIntV > &	TopCascVV
	)

Parallel implementaion of CascFind takes as input a directed graph and returns all the top cascades in TopCascVV.

Definition at line 200 of file casc.cpp.

                                                                                                                       {
  // Attribute to Int mapping
  TInt SIdx = P->GetColIdx(C1);
  TInt DIdx = P->GetColIdx(C2);
  TInt StIdx = P->GetColIdx(C3);
  TInt DuIdx = P->GetColIdx(C4);
  TIntV MapV, PhyV;
  TStrV SortBy;
  SortBy.Add(C3);
  P->Order(SortBy);
  int count = 0;
  for (TRowIterator RI = P->BegRI(); RI < P-> EndRI(); RI++) {
    MapV.Add(RI.GetRowIdx());
    PhyV.Add(count++);
  }
  P->StoreIntCol("Physical",PhyV);
  TInt PIdx = P->GetColIdx("Physical");
  TIntV GNodeV;
  for (TNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NI.GetInDeg() == 0) { GNodeV.Add(NI.GetId()); }
  }
  TVec<TIntV> ThTopCascVV; // for each thread
  #pragma omp parallel private(ThTopCascVV) num_threads(10)
  {
    #pragma omp for schedule(dynamic,1000)
    for (int i = 0; i < GNodeV.Len(); i++) {
      TIntV CurCasc;
      TSnapQueue<TInt> EventQ;
      THashSet<TInt> VisitedH;
      TInt NId = GNodeV[i];
      EventQ.Push(NId);
      VisitedH.AddKey(NId);
      CurCasc.Add(P->GetIntValAtRowIdx(PIdx,NId));
      while (! EventQ.Empty()) {
        TNGraph::TNodeI CNI = Graph->GetNI(EventQ.Top().Val); //Get Current Node
        EventQ.Pop();
        // Go over the outdegree nodes of the currernt node
        for (int e = 0; e < CNI.GetOutDeg(); e++) {
          TInt CId = CNI.GetOutNId(e);
          if ( !VisitedH.IsKey(CId)) {
            EventQ.Push(CId);
            VisitedH.AddKey(CId);
            CurCasc.Add(P->GetIntValAtRowIdx(PIdx,CId));
          }
        }
      }
      CurCasc.Sort();
      TIntV ToAddV;
      for (TIntV::TIter VI = CurCasc.BegI(); VI < CurCasc.EndI(); VI++) {
        ToAddV.Add(MapV.GetVal(VI->Val));
      }
      if (ToAddV.Len() > 1) { ThTopCascVV.Add(ToAddV);}  
    }
    #pragma omp critical
    {
      for (int j = 0; j < ThTopCascVV.Len(); j++) {
        TopCascVV.Add(ThTopCascVV[j]);
      }
    }
  }
  return;
}

PNGraph TSnap::CascGraph	(	PTable	P,
		const TStr	C1,
		const TStr	C2,
		const TStr	C3,
		const TStr	C4,
		const TInt	W,
		bool	SortParam
	)

Takes as input the column names of the PTable P as C1, C2, C3 and C4 and returns a directed graph of W-adjacent events. By default calls CascGraphSource. Toggle SortParam to use CascGraphTime.

Definition at line 126 of file casc.cpp.

                                                                                                                {
  if (SortParam) {
    return CascGraphSource(P, C1, C2, C3, C4, W);
  }
  else {
    return CascGraphTime(P, C1, C2, C3, C4, W);
  }
}

PNGraph TSnap::CascGraphSource	(	PTable	P,
		const TStr	C1,
		const TStr	C2,
		const TStr	C3,
		const TStr	C4,
		const TInt	W
	)

Takes as input the column names of the PTable P as C1, C2,C3 and C4 and returns a directed graph of W-adjacent events. For graph generation events are sorted by C1.

Definition at line 3 of file casc.cpp.

                                                                                                       {
  // Attribute to Int mapping
  TInt SIdx = P->GetColIdx(C1); //Source
  TInt DIdx = P->GetColIdx(C2); //Dest
  TInt StIdx = P->GetColIdx(C3); //Start
  TInt DuIdx = P->GetColIdx(C4); //Duration
  TIntV MapV;
  TStrV SortBy;
  SortBy.Add(C1);
  P->Order(SortBy);
  TIntV Source; 
  P->ReadIntCol(C1,Source);
  PNGraph Graph = TNGraph::New();
  //Add Nodes
  for (TRowIterator RI = P->BegRI(); RI < P-> EndRI(); RI++) {
    Graph->AddNode(RI.GetRowIdx().Val);
    MapV.Add(RI.GetRowIdx());
  }
  //Add Edges
  for (TRowIterator OI = P->BegRI(); OI < P->EndRI(); OI++) {
    int OIdx = OI.GetRowIdx().Val;
    int ODest = P->GetIntValAtRowIdx(DIdx,OIdx).Val;
    int OStart = P->GetIntValAtRowIdx(StIdx,OIdx).Val;
    int ODur = P->GetIntValAtRowIdx(DuIdx,OIdx).Val;
    // Inline binary Search
    int val = ODest;
    int lo = 0;
    int hi = Source.Len() - 1;
    int index = -1;
    while (hi >= lo) {
      int mid = lo + (hi - lo)/2;
      if (Source.GetVal(mid) > val) { hi = mid - 1;}
      else if (Source.GetVal(mid) < val) { lo = mid + 1;}
      else { index = mid; hi = mid - 1;}
    }
    // End of binary Search
    if (index < 0) {
      continue;
    }
    int BIdx = index;
    for(int i = BIdx; i < Source.Len(); i++) {
      int InIdx = MapV.GetVal(i).Val;
      if (InIdx == OIdx) {continue;}
      int InSource = P->GetIntValAtRowIdx(SIdx,InIdx).Val;
      int InStart = P->GetIntValAtRowIdx(StIdx,InIdx).Val;
      if (InSource != ODest) { break;}
      if (InStart >= (ODur + OStart) && InStart - (ODur + OStart) <= W.Val) {
        if (!Graph->IsEdge(OIdx,InIdx)) {
          Graph->AddEdge(OIdx,InIdx);
        }
      }      
    }
  }
  return Graph;
}

PNGraph TSnap::CascGraphTime	(	PTable	P,
		const TStr	C1,
		const TStr	C2,
		const TStr	C3,
		const TStr	C4,
		const TInt	W
	)

Takes as input the column names of the PTable P as C1, C2,C3 and C4 and returns a directed graph of W-adjacent events. For graph generation events are sorted by C3.

Definition at line 59 of file casc.cpp.

                                                                                                     {
  // Attribute to Int mapping
  TInt SIdx = P->GetColIdx(C1); //Source
  TInt DIdx = P->GetColIdx(C2); //Dest
  TInt StIdx = P->GetColIdx(C3); //Start
  TInt DuIdx = P->GetColIdx(C4); //Duration
  TIntV MapV;
  TStrV SortBy;
  SortBy.Add(C3);
  P->Order(SortBy);
  TIntV Start; 
  P->ReadIntCol(C3,Start);
  PNGraph Graph = TNGraph::New();
  //Add Nodes
  for (TRowIterator RI = P->BegRI(); RI < P-> EndRI(); RI++) {
    Graph->AddNode(RI.GetRowIdx().Val);
    MapV.Add(RI.GetRowIdx());
  }
  //Add Edges
  for (TRowIterator OI = P->BegRI(); OI < P->EndRI(); OI++) {
    int OIdx = OI.GetRowIdx().Val;
    int ODest = P->GetIntValAtRowIdx(DIdx,OIdx).Val;
    int OStart = P->GetIntValAtRowIdx(StIdx,OIdx).Val;
    int ODur = P->GetIntValAtRowIdx(DuIdx,OIdx).Val;
    // Inline binary Search
    int val = OStart + ODur;
    int lo = 0;
    int hi = Start.Len() - 1;
    int index = -1;
    if (val >= Start.GetVal(hi)) { val = Start.GetVal(hi);}
    while (hi >= lo) {
      int mid = lo + (hi - lo)/2;
      if (Start.GetVal(mid) > val) {
        if ((mid-1) >= lo  &&  Start.GetVal(mid - 1) < val) {
          index = mid - 1;break;
        }
        hi = mid - 1;
      }
      else if (Start.GetVal(mid) < val) {
        if (mid + 1 <= hi  &&  Start.GetVal(mid + 1) > val) {
          index = mid;break;
        }
        lo = mid + 1;
      }
      else { index = mid; hi = mid - 1;}
    }
    // End of binary Search
    if (index < 0) {
      continue;
    }
    int BIdx = index;
    for(int i = BIdx; i < Start.Len(); i++) {
      int InIdx = MapV.GetVal(i).Val;
      if (InIdx == OIdx) {continue;}
      int InSource = P->GetIntValAtRowIdx(SIdx,InIdx).Val;
      int InStart = P->GetIntValAtRowIdx(StIdx,InIdx).Val;
      if (InStart - (ODur + OStart) > W.Val) { break;}
      if (InSource == ODest && InStart >= (ODur + OStart)) {
        if (!Graph->IsEdge(OIdx,InIdx)) {
          Graph->AddEdge(OIdx,InIdx);
        }
      }      
    }
  }
  return Graph;
}

void TSnap::CmtyEvolutionFileBatch	(	TStr	InFNm,
		TIntIntHH &	sizesCont,
		TIntIntHH &	cCont,
		TIntIntVH &	edges,
		double	alpha,
		double	beta,
		int	CmtyAlg
	)

Definition at line 490 of file cmty.cpp.

                                                                                                                                          {


  // reading folder with networks and calculating core/periphery
  int br = 0;
  TIntIntH prev;
  TIntH prev_sizes;

  TSsParser Ss(InFNm, ssfWhiteSep, true, false, true);
  Ss.Next();
  //int internal_year_counter = 0;
  // variable for delimiter between networks
  TStr Marker;
  // defining variables for node ids and starting year
  int SrcNId, DstNId; // , t = 1970;

  // temporal container for edges
  TIntIntVH edges_;

  while (!Ss.Eof()) {

    //printf("%i\n", t);
    Marker = Ss.GetLnStr();
    // get the year from the network seperator
    //t = Marker.GetSubStr(1, 4).GetInt();

    if (Marker.GetCh(0) == '#'){

      Ss.Next();
      PUNGraph Graph = PUNGraph::TObj::New();
      do{
        if (!Ss.GetInt(0, SrcNId) || !Ss.GetInt(1, DstNId)) {
          if (!Ss.Eof()){
            Ss.Next();
            if (!Ss.Eof())
              Marker = Ss.GetLnStr();
          }
          continue;
        }
        if (!Graph->IsNode(SrcNId)) { Graph->AddNode(SrcNId); }
        if (!Graph->IsNode(DstNId)) { Graph->AddNode(DstNId); }
        Graph->AddEdge(SrcNId, DstNId);
        Ss.Next();
        if (!Ss.Eof())
          Marker = Ss.GetLnStr();
      } while (Marker.GetCh(0) != '#' && !Ss.Eof());


      if (Graph->GetNodes()>0) {
        // WORK

        TSnap::DelSelfEdges(Graph);
        TCnComV CmtyV;
        //double Q = 0.0;
        TStr CmtyAlgStr;
        if (CmtyAlg == 1) {
          CmtyAlgStr = "Girvan-Newman";
          //Q = TSnap::CommunityGirvanNewman(Graph, CmtyV);
        }
        else if (CmtyAlg == 2) {
          CmtyAlgStr = "Clauset-Newman-Moore";
          //Q = TSnap::CommunityCNM(Graph, CmtyV);
        }
        else if (CmtyAlg == 3) {
          CmtyAlgStr = "Infomap";
          //Q = TSnap::Infomap(Graph, CmtyV);
        }
        else { Fail; }

        TIntIntHH distCont;

        if (br == 0) {
          prev.Clr();
          //int size = 0;
          for (int c = 0; c < CmtyV.Len(); c++) {
            for (int i = 0; i < CmtyV[c].Len(); i++){
              prev.AddDat(CmtyV[c][i].Val, c);
            }
            //int s = CmtyV[c].Len();
            prev_sizes.AddDat(c, CmtyV[c].Len());
          }
        }
        else {

          // containers for statistics

          //TIntFltHH stat1;
          //TIntIntHH stat2;
          TIntH dist;
          TIntH map;

          int first_new_c_id = -1;

          // getting first free id for a new community
          for (THashKeyDatI<TInt, TInt> it = prev_sizes.BegI(); !it.IsEnd(); it++)
            if (it.GetKey() > first_new_c_id)
              first_new_c_id = it.GetKey();
          if (CmtyV.Len() - 1>first_new_c_id)
            first_new_c_id = CmtyV.Len() - 1;
          first_new_c_id++;

          for (int c = 0; c < CmtyV.Len(); c++) {

            TIntV stat;
            TIntFltH statH1;
            TIntFltH statH2;

            // initialize distributions to 0
            for (THashKeyDatI<TInt, TInt> it = prev_sizes.BegI(); !it.IsEnd(); it++)
              dist.AddDat(it.GetKey(), 0);
            //for new nodes
            dist.AddDat(-1, 0);

            for (int i = 0; i < CmtyV[c].Len(); i++) {
              int id = CmtyV[c][i].Val;
              int prev_comm = -1;
              if (prev.IsKey(id))
                prev_comm = prev.GetDat(CmtyV[c][i].Val);
              stat.Add(prev_comm);
              int pre_val = dist.GetDat(prev_comm);
              dist.AddDat(prev_comm, pre_val + 1);
            }

            double sumstat2 = 0;
            for (THashKeyDatI<TInt, TInt> it = dist.BegI(); !it.IsEnd(); it++) {

              int k = it.GetKey();
              int d = it.GetDat();
              if (d > 0){
                if (prev_sizes.IsKey(it.GetKey())){

                  double stat1_ = (double)d / (double)prev_sizes.GetDat(k);
                  statH1.AddDat(k, stat1_);
                }
                double stat2_ = (double)d / (double)CmtyV[c].Len();
                statH2.AddDat(k, stat2_);
                sumstat2 += stat2_;

                TIntV edge;
                edge.Add(k);
                edge.Add(c);
                edge.Add(d);
                edge.Add(br - 1);
                edge.Add(br);
                edges_.AddDat(edges_.Len() + 1, edge);
              }

              // adding edges between two communities in two neighbouring time points;


              if (sumstat2 > 0.98) break;
            }

            int n_of_c_greater_than_half = 0;
            int id_of_c_greater_than_half = -1;
            TIntV ids_of_c_greater_than_half;

            for (THashKeyDatI<TInt, TFlt> it = statH1.BegI(); !it.IsEnd(); it++){
              if (it.GetDat()>alpha){
                id_of_c_greater_than_half = it.GetKey();
                ids_of_c_greater_than_half.Add(it.GetKey());
                n_of_c_greater_than_half++;
              }
            }

            // if this community is build of majority of one previous community and the other parts of the community are fractions of other communities smaller than half, the new community gets its label 
            if (n_of_c_greater_than_half == 1){
              map.AddDat(c, id_of_c_greater_than_half);
            }
            else{
              int h2part_id = -2;
              for (int i = 0; i<ids_of_c_greater_than_half.Len(); i++){
                double H2 = statH2.GetDat(ids_of_c_greater_than_half[i]);
                if (H2>beta){
                  h2part_id = ids_of_c_greater_than_half[i];
                }
              }
              if (h2part_id != -2)
                map.AddDat(c, h2part_id);
              else{
                map.AddDat(c, first_new_c_id);
                first_new_c_id++;
              }
            }

            distCont.AddDat(c, dist);

            //stat1.AddDat(c,statH1);
            //stat2.AddDat(c,statH2);

          }


          prev.Clr();
          prev_sizes.Clr();
          for (int c = 0; c < CmtyV.Len(); c++){
            for (int i = 0; i < CmtyV[c].Len(); i++){
              prev.AddDat(CmtyV[c][i].Val, map.GetDat(c));
            }
            //int s = CmtyV[c].Len();
            prev_sizes.AddDat(map.GetDat(c), CmtyV[c].Len());
          }

          // filing the edges container - the key thing is the map(c)
          for (THashKeyDatI<TInt, TIntV> it = edges_.BegI(); !it.IsEnd(); it++){
            TIntV edgesV;
            int a = it.GetDat()[0];
            int b = it.GetDat()[1];
            int v = it.GetDat()[2];
            int d = it.GetDat()[3];
            int e = it.GetDat()[4];
            edgesV.Add(map.GetDat(b));
            edgesV.Add(a);
            edgesV.Add(v);
            edgesV.Add(d);
            edgesV.Add(e);
            if (a != -1)
              edges.AddDat(edges.Len(), edgesV);
          }
          edges_.Clr();


        }

        sizesCont.AddDat(br, prev_sizes);
        cCont.AddDat(br, prev);
        br++;
        // WORK - END
      }
    }
    else Ss.Next();
  }

}

void TSnap::CmtyEvolutionFileBatchV	(	TStr	InFNm,
		TIntIntVH &	sizesContV,
		TIntIntVH &	cContV,
		TIntIntVH &	edges,
		double	alpha,
		double	beta,
		int	CmtyAlg
	)

Definition at line 441 of file cmty.cpp.

                                                                                                                                             {
  TIntIntHH sizesCont;
  TIntIntHH cCont;
  CmtyEvolutionFileBatch(InFNm, sizesCont, cCont, edges, alpha, beta, CmtyAlg);

  TIntV uniqueId;
  for (int i = 0; i < cCont.Len(); i++){
    for (THashKeyDatI<TInt, TInt> it = cCont[i].BegI(); !it.IsEnd(); it++){
      if (!uniqueId.IsIn(it.GetKey()))
        uniqueId.Add(it.GetKey());
    }
  }

  for (int j = 0; j<uniqueId.Len(); j++)
  {
    TIntV cV;
    for (int i = 0; i<cCont.Len(); i++)
    {
      if (cCont[i].IsKey(uniqueId[j]))
        cV.Add(cCont[i].GetDat(uniqueId[j]));
      else
        cV.Add(-1);
    }
    cContV.AddDat(uniqueId[j], cV);
  }

  TIntV uniqueC;
  for (int i = 0; i < sizesCont.Len(); i++){
    for (THashKeyDatI<TInt, TInt> it = sizesCont[i].BegI(); !it.IsEnd(); it++){
      if (!uniqueC.IsIn(it.GetKey()))
        uniqueC.Add(it.GetKey());
    }
  }

  for (int j = 0; j<uniqueC.Len(); j++)
  {
    TIntV cV;
    for (int i = 0; i<sizesCont.Len(); i++)
    {
      if (sizesCont[i].IsKey(uniqueC[j]))
        cV.Add(sizesCont[i].GetDat(uniqueC[j]));
      else
        cV.Add(0);
    }
    sizesContV.AddDat(uniqueC[j], cV);
  }

}

void TSnap::CmtyEvolutionJson	(	TStr &	Json,
		TIntIntVH &	sizesContV,
		TIntIntVH &	cContV,
		TIntIntVH &	edges
	)

Definition at line 725 of file cmty.cpp.

                                                                                              {
  // This function creates a JSON string with communities and edges for community evolution visualization using D3.js

  // writing json label for edges
  Json.InsStr(Json.Len(), "{\n\"edges\":[\n");

  TInt br = 0;
  // iterating hash of vector of edges and writing into string 
  for (THashKeyDatI<TInt, TIntV> it = edges.BegI(); !it.IsEnd(); it++)
  {
    // first node
    TInt n1 = it.GetDat()[1];
    // second node
    TInt n2 = it.GetDat()[0];
    // edge weight
    TInt w = it.GetDat()[2];
    // start time point
    TInt t0 = it.GetDat()[3];
    // end time point
    TInt t1 = it.GetDat()[4];

    if (br>0)
      Json.InsStr(Json.Len(), ",");

    // writing to string
    Json.InsStr(Json.Len(), "{\"n1\":"); Json.InsStr(Json.Len(), n1.GetStr());
    Json.InsStr(Json.Len(), ", \"n2\":"); Json.InsStr(Json.Len(), n2.GetStr());
    Json.InsStr(Json.Len(), ", \"w\":"); Json.InsStr(Json.Len(), w.GetStr());
    Json.InsStr(Json.Len(), ", \"t0\":"); Json.InsStr(Json.Len(), t0.GetStr());
    Json.InsStr(Json.Len(), ", \"t1\":"); Json.InsStr(Json.Len(), t1.GetStr());
    Json.InsStr(Json.Len(), " }\n");
    br++;
  }

  // json label for communities
  Json.InsStr(Json.Len(), "],\n\"communities\":[\n");

  br = 0;
  // printing communities into json file 
  for (int i = 0; i < sizesContV[0].Len(); i++)
  {
    for (THashKeyDatI<TInt, TIntV> it = sizesContV.BegI(); !it.IsEnd(); it++)
    {
      // id of community
      TInt id = it.GetKey();
      // community size
      TInt size = it.GetDat()[i];
      // time
      TInt j = i;

      // if the community has size greater than 0, output it to json string
      if (size > 0) {
        if (br>0)
          Json.InsStr(Json.Len(), ",");

        TInt size = it.GetDat()[i];
        Json.InsStr(Json.Len(), "{\"id\":"); Json.InsStr(Json.Len(), id.GetStr());
        Json.InsStr(Json.Len(), ", \"size\":"); Json.InsStr(Json.Len(), size.GetStr());
        Json.InsStr(Json.Len(), ", \"t\":"); Json.InsStr(Json.Len(), j.GetStr());
        Json.InsStr(Json.Len(), " }\n");

        br++;
      }
    }
  }

  // printing communities into json file - alternative ordering
  /*
  for (THashKeyDatI<TInt, TIntV> it = sizesContV.BegI();  !it.IsEnd(); it++)
  {
  TInt id = it.GetKey();
  int len = it.GetDat().Len();
  for (int i=0; i < it.GetDat().Len(); i++)
  {
  TInt size = it.GetDat()[i];
  TInt j = i;
  if (size > 0) {

  if(br>0)
  Json.InsStr(Json.Len(),",");

  TInt size = it.GetDat()[i];

  Json.InsStr(Json.Len(),"{\"id\":"); Json.InsStr(Json.Len(),id.GetStr());
  Json.InsStr(Json.Len(),", \"size\":"); Json.InsStr(Json.Len(),size.GetStr());
  Json.InsStr(Json.Len(),", \"t\":"); Json.InsStr(Json.Len(),j.GetStr());
  Json.InsStr(Json.Len()," }\n");

  br++;

  }

  }
  }
  */

  Json.InsStr(Json.Len(), "]\n}");

}

TStr TSnap::CmtyTest	(	TStr	InFNm,
		int	CmtyAlg
	)

Definition at line 827 of file cmty.cpp.

                                      {

  TIntIntVH sizesContV;
  TIntIntVH cContV;
  TIntIntVH edges;
  double alpha = 0.5;
  double beta = 0.75;
  CmtyEvolutionFileBatchV(InFNm, sizesContV, cContV, edges, alpha, beta, CmtyAlg);
  TStr out;
  //int a = sizesContV.Len();
  //int b = cContV.Len();
  //int c = edges.Len();
  CmtyEvolutionJson(out, sizesContV, cContV, edges);

  return out;
}

template<class PGraph >

int TSnap::CntDegNodes	(	const PGraph &	Graph,
		const int &	NodeDeg
	)

Returns the number of nodes with degree NodeDeg.

Definition at line 105 of file alg.h.

                                                         {
  int Cnt = 0;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NI.GetDeg() == NodeDeg) Cnt++;
  }
  return Cnt;
}

template<class PGraph >

int TSnap::CntEdgesToSet	(	const PGraph &	Graph,
		const int &	NId,
		const TIntSet &	NodeSet
	)

Returns the number of nodes in NodeSet that have an edge to the node NId.

Definition at line 123 of file alg.h.

                                                                               {
  if (! Graph->IsNode(NId)) { return 0; }
  const bool IsDir = Graph->HasFlag(gfDirected);
  const typename PGraph::TObj::TNodeI NI = Graph->GetNI(NId);
  if (! IsDir) {
    int EdgesToSet = 0;
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      if (NodeSet.IsKey(NI.GetOutNId(e))) { EdgesToSet++; } }
    return EdgesToSet;
  } else {
    TIntSet Set(NI.GetDeg());
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      if (NodeSet.IsKey(NI.GetOutNId(e))) { Set.AddKey(NI.GetOutNId(e)); } }
    for (int e = 0; e < NI.GetInDeg(); e++) {
      if (NodeSet.IsKey(NI.GetInNId(e))) { Set.AddKey(NI.GetInNId(e)); } }
    return Set.Len();
  }
}

template<class PGraph >

int TSnap::CntInDegNodes	(	const PGraph &	Graph,
		const int &	NodeInDeg
	)

Returns the number of nodes with in-degree NodeInDeg.

Definition at line 87 of file alg.h.

                                                             {
  int Cnt = 0;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NI.GetInDeg() == NodeInDeg) Cnt++;
  }
  return Cnt;
}

template<class PGraph >

int TSnap::CntNonZNodes

(

const PGraph &

Graph

)

Returns the number of nodes with degree greater than 0.

Definition at line 114 of file alg.h.

                                      {
  int Cnt = 0;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NI.GetDeg() > 0) Cnt++;
  }
  return Cnt;
}

template<class PGraph >

int TSnap::CntOutDegNodes	(	const PGraph &	Graph,
		const int &	NodeOutDeg
	)

Returns the number of nodes with out-degree NodeOutDeg.

Definition at line 96 of file alg.h.

                                                               {
  int Cnt = 0;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NI.GetOutDeg() == NodeOutDeg) Cnt++;
  }
  return Cnt;
}

template<class PGraph >

int TSnap::CntSelfEdges

(

const PGraph &

Graph

)

Counts the number of self-edges in a graph. Edge (u,u) is a self-edge.

Definition at line 334 of file alg.h.

                                      {
  int Cnt = 0;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      if (NI.GetId() == NI.GetOutNId(e)) { Cnt++; }
    }
  }
  return Cnt;
}

template<class PGraph >

int TSnap::CntUniqBiDirEdges

(

const PGraph &

Graph

)

Counts unique bidirectional edges in the graph Graph. Edge is bidirectional if there exist directed edges in both directions: (u,v) and (v,u)

Definition at line 316 of file alg.h.

                                           {
  if (! Graph->HasFlag(gfDirected)) { // graph is undirected
    return CntUniqUndirEdges(Graph);  // then every edge is bi-directional
  }
  TIntSet NbrSet;
  int Cnt = 0;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    const int SrcId = NI.GetId();
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      const int DstId = NI.GetOutNId(e);
      if (DstId <= SrcId) { continue; } // count each un-dir edge only once
      if (Graph->IsEdge(DstId, SrcId)) { Cnt++; }
    }
  }
  return Cnt;
}

template<class PGraph >

int TSnap::CntUniqDirEdges

(

const PGraph &

Graph

)

Counts unique directed edges in the graph Graph. Nodes (u,v) (where u!=v) are connected via a directed edge if there exists a directed edge from node u to node v.

Definition at line 301 of file alg.h.

                                         {
  TIntSet NbrSet;
  int Cnt = 0;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    NbrSet.Clr(false);
    for (int e = 0; e < NI.GetOutDeg(); e++) { // unique out-neighbors of a node
      if (NI.GetOutNId(e) != NI.GetId()) { // skip self-edges
        NbrSet.AddKey(NI.GetOutNId(e)); }
    }
    Cnt += NbrSet.Len();
  }
  return Cnt;
}

template<class PGraph >

int TSnap::CntUniqUndirEdges

(

const PGraph &

Graph

)

Counts unique undirected edges in the graph Graph. Nodes (u,v) (where u!=v) are connected via an undirected edge if there exists an edge in either direction (u,v) or (v,u).

Definition at line 279 of file alg.h.

                                           {
  TIntSet NbrSet;
  TIntSet SelfNbrSet;
  int Cnt = 0;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    NbrSet.Clr(false);
    for (int e = 0; e < NI.GetDeg(); e++) { // unique neighbors of a node
      const int NbrId = NI.GetNbrNId(e);
      if (NbrId == NI.GetId()) { // remember self-edges
        SelfNbrSet.AddKey(NbrId);
      } else {
        NbrSet.AddKey(NbrId);
      }
    }
    Cnt += NbrSet.Len();
  }
  // OP RS 2014/06/11 self-edges are currently not used 
  //return Cnt / 2 + SelfNbrSet.Len();
  return Cnt / 2;
}

double TSnap::CommunityCNM	(	const PUNGraph &	Graph,
		TCnComV &	CmtyV
	)

Clauset-Newman-Moore community detection method for large networks. At every step of the algorithm two communities that contribute maximum positive value to global modularity are merged. See: Finding community structure in very large networks, A. Clauset, M.E.J. Newman, C. Moore, 2004

Definition at line 1449 of file cmty.cpp.

                                                           {
  return TSnapDetail::TCNMQMatrix::CmtyCMN(Graph, CmtyV);
}

double TSnap::CommunityGirvanNewman	(	PUNGraph &	Graph,
		TCnComV &	CmtyV
	)

Girvan-Newman community detection algorithm based on Betweenness centrality. See: Girvan M. and Newman M. E. J., Community structure in social and biological networks, Proc. Natl. Acad. Sci. USA 99, 7821-7826 (2002)

Definition at line 312 of file cmty.cpp.

                                                              {
  PUNGraph LocalGraph = TSnap::ConvertGraph<PUNGraph>(Graph, false);

  TIntH OutDegH;
  const int NEdges = LocalGraph->GetEdges();
  for (TUNGraph::TNodeI NI = LocalGraph->BegNI(); NI < LocalGraph->EndNI(); NI++) {
    OutDegH.AddDat(NI.GetId(), NI.GetOutDeg());
  }
  double BestQ = -1; // modularity
  TCnComV CurCmtyV;
  CmtyV.Clr();
  TIntV Cmty1, Cmty2;
  while (true) {
    TSnapDetail::CmtyGirvanNewmanStep(LocalGraph, Cmty1, Cmty2);
    const double Q = TSnapDetail::_GirvanNewmanGetModularity(LocalGraph, OutDegH, NEdges, CurCmtyV);
    //printf("current modularity: %f\n", Q);
    if (Q > BestQ) {
      BestQ = Q; 
      CmtyV.Swap(CurCmtyV);
    }
    if (Cmty1.Len() == 0 || Cmty2.Len() == 0) { break; }
  }
  return BestQ;
}

template<class POutGraph , class PInGraph >

POutGraph TSnap::ConvertESubGraph	(	const PInGraph &	InGraph,
		const TIntV &	EIdV,
		const bool &	RenumberNodes = false
	)

Returns a subgraph of graph InGraph with EIdV edges with an optional node renumbering.

Creates a subgraph of the input graph InGraph on EIdV edges and returns an output graph. Input and output graphs can have different types. Node and edge data is not copied, but it is shared by input and output graphs.

Parameter RenumberNodes determines, whether the node IDs are preserved or not. If RenumberNodes is false, then nodes in the resulting graph have the same node IDs as nodes in InGraph. If RenumberNodes is true, then nodes in the resulting graph are renumbered sequentially from 0 to N-1. By default, the nodes are not renumbered.

Definition at line 441 of file subgraph.h.

                                                                                                  {
  CAssert(HasGraphFlag(typename PInGraph::TObj, gfMultiGraph)); // needs to have explicit edges
  POutGraph NewGraphPt = POutGraph::TObj::New();
  typename POutGraph::TObj& NewGraph = *NewGraphPt;
  NewGraph.Reserve(-1, EIdV.Len());
  if (! RenumberNodes) {
    for (int edge = 0; edge < EIdV.Len(); edge++) {
      const int EId = EIdV[edge];
      IAssert(InGraph->IsEdge(EId));
      const typename PInGraph::TObj::TEdgeI EI = InGraph->GetEI(EId);
      const int SrcNId = EI.GetSrcNId();
      const int DstNId = EI.GetDstNId();
      if (! NewGraph.IsNode(SrcNId)) {
        NewGraph.AddNode(SrcNId); }
      if (! NewGraph.IsNode(DstNId)) {
        NewGraph.AddNode(DstNId); }
      NewGraph.AddEdge(SrcNId, DstNId);
    }
  } else {
    // renumber nodes so that node ids are 0...N-1
    TIntSet NIdSet(InGraph->GetNodes());
    for (int edge = 0; edge < EIdV.Len(); edge++) {
      const int EId = EIdV[edge];
      IAssert(InGraph->IsEdge(EId));
      const typename PInGraph::TObj::TEdgeI EI = InGraph->GetEI(EId);
      const int SrcNId = NIdSet.AddKey(EI.GetSrcNId()); // map node ids
      const int DstNId = NIdSet.AddKey(EI.GetDstNId());
      if (! NewGraph.IsNode(SrcNId)) {
        NewGraph.AddNode(SrcNId); }
      if (! NewGraph.IsNode(DstNId)) {
        NewGraph.AddNode(DstNId); }
      NewGraph.AddEdge(SrcNId, DstNId);
    }
  }
  return NewGraphPt;
}

template<class POutGraph , class PInGraph >

POutGraph TSnap::ConvertGraph	(	const PInGraph &	InGraph,
		const bool &	RenumberNodes = false
	)

Performs conversion of graph InGraph with an optional node renumbering.

Takes an input graph InGraph and returns an output graph. Input and output graphs can have different types. Node and edge data is not copied, but it is shared by input and output graphs.

Parameter RenumberNodes determines, whether the node IDs are preserved or not. If RenumberNodes is false, then nodes in the resulting graph have the same node IDs as nodes in InGraph. If RenumberNodes is true, then nodes in the resulting graph are renumbered sequentially from 0 to N-1. By default, the nodes are not renumbered.

Definition at line 326 of file subgraph.h.

                                                                           {
  POutGraph OutGraphPt = POutGraph::TObj::New();
  typename POutGraph::TObj& OutGraph = *OutGraphPt;
  OutGraph.Reserve(InGraph->GetNodes(), InGraph->GetEdges());
  if (! RenumberNodes) {
    for (typename PInGraph::TObj::TNodeI NI = InGraph->BegNI(); NI < InGraph->EndNI(); NI++) {
      OutGraph.AddNode(NI.GetId());
    }
    for (typename PInGraph::TObj::TEdgeI EI = InGraph->BegEI(); EI < InGraph->EndEI(); EI++) {
      OutGraph.AddEdge(EI.GetSrcNId(), EI.GetDstNId());
      if (! HasGraphFlag(typename PInGraph::TObj, gfDirected) && HasGraphFlag(typename POutGraph::TObj, gfDirected)) { // add edge in the other direction
        OutGraph.AddEdge(EI.GetDstNId(), EI.GetSrcNId()); }
    }
  } else { // renumber nodes so that node ids are 0...N-1
    TIntSet NIdSet(InGraph->GetNodes());
    for (typename PInGraph::TObj::TNodeI NI = InGraph->BegNI(); NI < InGraph->EndNI(); NI++) {
      const int nid = NIdSet.AddKey(NI.GetId());
      OutGraph.AddNode(nid);
    }
    for (typename PInGraph::TObj::TEdgeI EI = InGraph->BegEI(); EI < InGraph->EndEI(); EI++) {
      const int SrcNId = NIdSet.GetKeyId(EI.GetSrcNId());
      const int DstNId = NIdSet.GetKeyId(EI.GetDstNId());
      OutGraph.AddEdge(SrcNId, DstNId);
      if (! HasGraphFlag(typename PInGraph::TObj, gfDirected) && HasGraphFlag(typename POutGraph::TObj, gfDirected)) {
        OutGraph.AddEdge(DstNId, SrcNId); }
    }
  }
  //OutGraph.Defrag();
  return OutGraphPt;
}

template<class POutGraph , class PInGraph >

POutGraph TSnap::ConvertSubGraph	(	const PInGraph &	InGraph,
		const TIntV &	NIdV,
		const bool &	RenumberNodes = false
	)

Returns an induced subgraph of graph InGraph with NIdV nodes with an optional node renumbering.

Creates a subgraph of the input graph InGraph on NIdV nodes and returns an output graph. Input and output graphs can have different types. Node and edge data is not copied, but it is shared by input and output graphs.

Parameter RenumberNodes determines, whether the node IDs are preserved or not. If RenumberNodes is false, then nodes in the resulting graph have the same node IDs as nodes in InGraph. If RenumberNodes is true, then nodes in the resulting graph are renumbered sequentially from 0 to N-1. By default, the nodes are not renumbered.

Definition at line 436 of file subgraph.h.

                                                                                                 {
  return TSnapDetail::TConvertSubGraph<POutGraph, PInGraph, HasGraphFlag(typename PInGraph::TObj, gfMultiGraph)>::Do(InGraph, NIdV, RenumberNodes);
}

template<class PGraph >

void TSnap::DelDegKNodes	(	PGraph &	Graph,
		const int &	OutDegK,
		const int &	InDegK
	)

Removes all the node of out-degree OutDegK and all the nodes of in-degree InDegK from the graph.

Definition at line 445 of file alg.h.

                                                                        {
  TIntV DelNIdV;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NI.GetOutDeg() == OutDegK || NI.GetInDeg() == InDegK) {
      DelNIdV.Add(NI.GetId());
    }
  }
  for (int i = 0; i < DelNIdV.Len(); i++) {
    Graph->DelNode(DelNIdV[i]);
  }
}

template<class PGraph >

void TSnap::DelNodes	(	PGraph &	Graph,
		const TIntV &	NIdV
	)

Removes nodes with ids stored in NIdV from the graph.

Definition at line 425 of file alg.h.

                                                {
  for (int n = 0; n < NIdV.Len(); n++) {
    Graph->DelNode(NIdV[n]);
  }
}

template<class PGraph >

void TSnap::DelSelfEdges

(

const PGraph &

Graph

)

Removes all the self-edges from the graph.

Definition at line 419 of file alg.h.

                                       {
  TSnapDetail::TDelSelfEdges<PGraph, HasGraphFlag(typename PGraph::TObj, gfMultiGraph)>
    ::Do(Graph);
}

template<class PGraph >

void TSnap::DelZeroDegNodes

(

PGraph &

Graph

)

Removes all the zero-degree nodes, that isolated nodes, from the graph.

Definition at line 432 of file alg.h.

                                    {
  TIntV DelNIdV;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NI.GetDeg() == 0) {
      DelNIdV.Add(NI.GetId());
    }
  }
  for (int i = 0; i < DelNIdV.Len(); i++) {
    Graph->DelNode(DelNIdV[i]);
  }
}

template<class PGraph >

void TSnap::DrawGViz	(	const PGraph &	Graph,
		const TGVizLayout &	Layout,
		const TStr &	PltFNm,
		const TStr &	Desc = TStr(),
		const bool &	NodeLabels = false,
		const TIntStrH &	NIdColorH = TIntStrH()
	)

Draws a given Graph using a selected GraphViz Layout engine with nodes colored.

Useful for drawing small (<100 node) graphs.

Parameters

PltFNm	Output filename (extension .ps, .png, .gif) determines the output format.
NIdColorH	Maps node ids to node colors (see GraphViz documentation for more details).

Definition at line 34 of file gviz.h.

                                                                                                                                                       {
  const TStr Ext = PltFNm.GetFExt();
  const TStr GraphFNm = PltFNm.GetSubStr(0, PltFNm.Len()-Ext.Len()) + "dot";
  SaveGViz(Graph, GraphFNm, Desc, NodeLabels, NIdColorH);
  TSnap::TSnapDetail::GVizDoLayout(GraphFNm, PltFNm, Layout);
}

template<class PGraph >

void TSnap::DrawGViz	(	const PGraph &	Graph,
		const TGVizLayout &	Layout,
		const TStr &	PltFNm,
		const TStr &	Desc,
		const TIntStrH &	NodeLabelH
	)

Draws a given Graph using a selected GraphViz Layout engine with nodes labeled.

Useful for drawing small (<100 node) graphs.

Parameters

PltFNm	Output filename (extension .ps, .png, .gif) determines the output format.
NIdColorH	Maps node ids to node colors (see GraphViz documentation for more details).

Definition at line 42 of file gviz.h.

                                                                                                                                {
  const TStr Ext = PltFNm.GetFExt();
  const TStr GraphFNm = PltFNm.GetSubStr(0, PltFNm.Len()-Ext.Len()) + "dot";
  SaveGViz(Graph, GraphFNm, Desc, NodeLabelH);
  TSnap::TSnapDetail::GVizDoLayout(GraphFNm, PltFNm, Layout);
}

TIntFltH TSnap::EventImportance	(	const PNGraph &	Graph,
		const int	k
	)

Event importance.

Definition at line 527 of file centr.cpp.

                                                            {
  TIntFltH NodeList; // values for nodese

  for (TNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++){
    NodeList.AddDat(NI.GetId(),NI.GetOutDeg());
  }


  for (THashKeyDatI<TInt,TFlt> NI = NodeList.BegI(); NI < NodeList.EndI(); NI++){
    int outdeg = Graph->GetNI(NI.GetKey()).GetOutDeg();
    int indeg = Graph->GetNI(NI.GetKey()).GetInDeg();
    
    if (outdeg>1 && indeg>0){
      double val = (1-(1/(double)outdeg))/(double)indeg;
      for(int i=0; i<(outdeg+indeg);i++){
        int NId = Graph->GetNI(NI.GetKey()).GetNbrNId(i);
        if (Graph->GetNI(NI.GetKey()).IsInNId(NId) == true){
        NodeList.AddDat(NId,NodeList.GetDat(NId)+val);
        }
        
      }
    }
    
  }

  return NodeList;
}

TIntFltH TSnap::EventImportance1	(	const PNGraph &	Graph,
		const int	k
	)

Definition at line 556 of file centr.cpp.

                                                              {
  TIntFltH NodeList; // values for nodese

  for (TNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++){
    NodeList.AddDat(NI.GetId(),NI.GetOutDeg());
  }


  for (THashKeyDatI<TInt,TFlt> NI = NodeList.BegI(); NI < NodeList.EndI(); NI++){
    int outdeg = Graph->GetNI(NI.GetKey()).GetOutDeg();
    int indeg = Graph->GetNI(NI.GetKey()).GetInDeg();
    
    if (outdeg>1 && indeg>0){
      double val = (1-(1/(double)outdeg))/(double)indeg;
      for(int i=0; i<(outdeg+indeg);i++){
        int NId = Graph->GetNI(NI.GetKey()).GetNbrNId(i);
        if (Graph->GetNI(NI.GetKey()).IsInNId(NId) == true){
        NodeList.AddDat(NId,NodeList.GetDat(NId)+val);
        }
        
      }
    }
    
  }

  return NodeList;
}

int TSnap::FastCorePeriphery	(	PUNGraph &	Graph,
		TIntIntH &	out
	)

Girvan-Newman community detection algorithm based on Betweenness centrality. See: Girvan M. and Newman M. E. J., Community structure in social and biological networks, Proc. Natl. Acad. Sci. USA 99, 7821-7826 (2002)

Definition at line 12 of file coreper.cpp.

                                                       {

    TIntIntH nodes;
    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}.

    double Zbest = 99999900000000000;
    int kbest = 0;
    
    int br=0;
    for (int k=0; k<nodes.Len(); k++){
      br++;
      Z = Z + br - 1 - nodes[k];
      if (Z < Zbest){ // or <=
        Zbest = Z;
        kbest = br;
      }
    }

    int cp = 0;
    br = 0;
    for (THashKeyDatI<TInt, TInt> it = nodes.BegI();  !it.IsEnd(); it++) {
      if (br < kbest)
        cp = 1;
      else
        cp = 0;
      out.AddDat(it.GetKey(), cp);
      br++;
    }

    return kbest;
  }

int TSnap::FastCorePeripheryGC	(	PUNGraph &	Graph,
		TIntIntH &	out
	)

Definition at line 56 of file coreper.cpp.

                                                         {
    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();
  }

int TSnap::FindAugV	(	const PNEANet &	Net,
		const int &	CapIndex,
		TIntV &	Flow,
		TIntQ &	FwdNodeQ,
		TIntH &	PredEdgeH,
		TIntQ &	BwdNodeQ,
		TIntH &	SuccEdgeH,
		TIntV &	MidToSrcAugV,
		TIntV &	MidToSnkAugV,
		const int &	SrcNId,
		const int &	SnkNId
	)

Returns the amount the flow can be augmented over the paths, 0 if no path can be found.

Find the augmenting path. Calls bidirectional BFS to find the path, and then builds the two path vectors.

Parameters

MidToSrcAugV	Contains the path vector from the midpoint node where the bi-d search met back to the source node.
MidToSnkAugV	Contains the path vector from the midpoint node where the bi-d search met back to the sink node.

Definition at line 71 of file flow.cpp.

                                                                                                                                                                                                                          {
  int MidPtNId = IntFlowBiDBFS(Net, CapIndex, Flow, FwdNodeQ, PredEdgeH, BwdNodeQ, SuccEdgeH, SrcNId, SnkNId);
  if (MidPtNId == -1) { return 0; }
  int MinAug = TInt::Mx, NId = MidPtNId, AugFlow = 0;
  // Build the path from the midpoint back to the source by tracing through the PredEdgeH
  for (int EId = PredEdgeH.GetDat(NId); NId != SrcNId; EId = PredEdgeH.GetDat(NId)) {
    MidToSrcAugV.Add(EId);
    const TNEANet::TEdgeI &EI = Net->GetEI(EId);
    if (EI.GetSrcNId() == NId) {
      NId = EI.GetDstNId();
      AugFlow = Flow[EId];
    } else {
      NId = EI.GetSrcNId();
      AugFlow = Net->GetIntAttrIndDatE(EId, CapIndex) - Flow[EId];
    }
    if (AugFlow < MinAug) { MinAug = AugFlow; }
  }
  NId = MidPtNId;
  // Build the path from the midpoint back to the sink by tracing through the SuccEdgeH
  for (int EId = SuccEdgeH.GetDat(NId); NId != SnkNId; EId = SuccEdgeH.GetDat(NId)) {
    MidToSnkAugV.Add(EId);
    const TNEANet::TEdgeI &EI = Net->GetEI(EId);
    if (EI.GetDstNId() == NId) {
      NId = EI.GetSrcNId();
      AugFlow = Flow[EId];
    } else {
      NId = EI.GetDstNId();
      AugFlow = Net->GetIntAttrIndDatE(EId, CapIndex) - Flow[EId];
    }
    if (AugFlow < MinAug) { MinAug = AugFlow; }
  }
  return MinAug;
}

int TSnap::findMinimum	(	TIntV &	Frontier,
		TIntFltH &	NIdDistH
	)

Definition at line 685 of file centr.cpp.

                                                     {
  TFlt minimum = TInt::Mx;
  int min_index = 0;
  for (int i = 0; i < Frontier.Len(); i++) {
    int NId = Frontier.GetVal(i);
    if (NIdDistH.GetDat(NId) < minimum) {
      minimum = NIdDistH.GetDat(NId);
      min_index = i;
    }
  }
  const int NId = Frontier.GetVal(min_index);
  Frontier.Del(min_index);
  return NId;
}

template<class PGraph >

PGraph TSnap::GenBaraHierar	(	const int &	Levels,
		const bool &	IsDir
	)

Generates a Ravasz-Barabasi deterministic scale-free graph.

Corners of the graph are recursively expanded with miniature copies of the base graph (below). The graph has power-law degree distribution with the exponent 1+ln(5)/ln(4) and clustering coefficient with power-law decay exponent -1. Base graph:

///   o---o
///   |\ /|
///   | o |
///   |/ \|
///   o---o
/// 

See: Hierarchical organization in complex networks. Ravasz and Barabasi. URL: http://arxiv.org/abs/cond-mat/0206130

Definition at line 174 of file ggen.h.

                                                           {
  const int Nodes = (int) TMath::Round(TMath::Power(5, Levels));
  PGraph GraphPt = PGraph::New();
  typename PGraph::TObj& Graph = *GraphPt;
  Graph.Reserve(Nodes, -1);
  // base graph
  for (int i = 0; i < 5; i++) { Graph.AddNode(i); }
  Graph.AddEdge(1,2);  Graph.AddEdge(2,3);
  Graph.AddEdge(3,4);  Graph.AddEdge(4,1);
  Graph.AddEdge(1,0);  Graph.AddEdge(3,0);
  Graph.AddEdge(2,0);  Graph.AddEdge(4,0);
  // expansion
  const int CenterId = 0;
  for (int lev = 1; lev < Levels+1; lev++) {
    const int MxNId = Graph.GetNodes();
    // make 4 duplicate copies
    for (int d = 0; d < 4; d++) {
      for (int n = 0; n < MxNId; n++) { Graph.AddNode(); }
      for (int n = 0; n < MxNId; n++) {
        typename PGraph::TObj::TNodeI NI = Graph.GetNI(n);
        const int SrcId = n+MxNId*(d+1);
        for (int e = 0; e < NI.GetOutDeg(); e++) {
          Graph.AddEdge(SrcId, NI.GetOutNId(e)+MxNId*(d+1));
        }
      }
    }
    // add edges to the center
    //const int LevPow = (int)TMath::Round(TMath::Power(5,lev-1));
    for (int n = MxNId; n < Graph.GetNodes(); n++) {
      //typename PGraph::TObj::TNodeI NI = Graph.GetNI(n);
      const int SrcId = n;
      int Pow = 1;  bool Skip = false;
      for (int p = 1; p <= lev; p++) {
        if (SrcId % (5*Pow) < Pow) { Skip=true; break; }
        Pow *= 5;
      }
      if (Skip) { continue; }
      Graph.AddEdge(SrcId, CenterId);
    }
  }
  return GraphPt;
}

template<class PGraph >

PGraph TSnap::GenCircle	(	const int &	Nodes,
		const int &	NodeOutDeg = 1,
		const bool &	IsDir = true
	)

Generates a circle graph where every node creates out-links to NodeOutDeg forward nodes.

Definition at line 104 of file ggen.h.

                                                                             {
  PGraph Graph = PGraph::TObj::New();
  Graph->Reserve(Nodes, Nodes*NodeOutDeg);
  for (int n = 0; n < Nodes; n++) {
    Graph->AddNode(n); }
  for (int n = 0; n < Nodes; n++) {
    for (int x = 0; x < NodeOutDeg; x++) {
      Graph->AddEdge(n, (n+x+1) % Nodes);
      if (Graph->HasFlag(gfDirected) && ! IsDir) { Graph->AddEdge((n+x+1) % Nodes, n); }
    }
  }
  return Graph;
}

PUNGraph TSnap::GenConfModel	(	const TIntV &	DegSeqV,
		TRnd &	Rnd
	)

Generates a random undirect graph with a given degree sequence.

Generates a random undirect graph with a given degree sequence DegSeqV. Configuration model operates as follows. For each node N, of degree DeqSeqV[N] we create DeqSeqV[N] spokes (half-edges). We then pick two spokes at random, and connect the spokes endpoints. We continue this process until no spokes are left. Generally this generates a multigraph (i.e., spokes out of same nodes can be chosen multiple times).We ignore (discard) self-loops and multiple edges. Thus, the generated graph will only approximate follow the given degree sequence. The method is very fast!

Definition at line 122 of file ggen.cpp.

                                                       {
  const int Nodes = DegSeqV.Len();
  PUNGraph GraphPt = TUNGraph::New();
  TUNGraph& Graph = *GraphPt;
  Graph.Reserve(Nodes, -1);
  TIntV NIdDegV(DegSeqV.Len(), 0);
  int DegSum=0, edges=0;
  for (int node = 0; node < Nodes; node++) {
    Graph.AddNode(node);
    for (int d = 0; d < DegSeqV[node]; d++) { NIdDegV.Add(node); }
    DegSum += DegSeqV[node];
  }
  NIdDegV.Shuffle(Rnd);
  TIntPrSet EdgeH(DegSum/2); // set of all edges, is faster than graph edge lookup
  if (DegSum % 2 != 0) {
    printf("Seg seq is odd [%d]: ", DegSeqV.Len());
    for (int d = 0; d < TMath::Mn(100, DegSeqV.Len()); d++) { printf("  %d", (int)DegSeqV[d]); }
    printf("\n");
  }
  int u=0, v=0;
  for (int c = 0; NIdDegV.Len() > 1; c++) {
    u = Rnd.GetUniDevInt(NIdDegV.Len());
    while ((v = Rnd.GetUniDevInt(NIdDegV.Len())) == u) { }
    if (u > v) { Swap(u, v); }
    const int E1 = NIdDegV[u];
    const int E2 = NIdDegV[v];
    if (v == NIdDegV.Len()-1) { NIdDegV.DelLast(); } 
    else { NIdDegV[v] = NIdDegV.Last();  NIdDegV.DelLast(); }
    if (u == NIdDegV.Len()-1) { NIdDegV.DelLast(); } 
    else { NIdDegV[u] = NIdDegV.Last();  NIdDegV.DelLast(); }
    if (E1 == E2 || EdgeH.IsKey(TIntPr(E1, E2))) { continue; }
    EdgeH.AddKey(TIntPr(E1, E2));
    Graph.AddEdge(E1, E2);
    edges++;
    if (c % (DegSum/100+1) == 0) { printf("\r configuration model: iter %d: edges: %d, left: %d", c, edges, NIdDegV.Len()/2); }
  }
  printf("\n");
  return GraphPt;
}

PUNGraph TSnap::GenConfModel

(

const PUNGraph &

G

)

Generate a random graph using (approximately) the same node degrees as in G using the configuration model.

Definition at line 338 of file ggen.cpp.

                                         {
  TIntV DegSeqV(G->GetNodes(), 0);
  TSnap::GetDegSeqV(G, DegSeqV);
  return TSnap::GenConfModel(DegSeqV);
}

PNGraph TSnap::GenCopyModel	(	const int &	Nodes,
		const double &	Beta,
		TRnd &	Rnd
	)

Generates a random scale-free network using the Copying Model.

Generates a random scale-free network using the Copying Model. The generating process operates as follows: Node u is added to a graph, it selects a random node v, and with prob Beta it links to v, with 1-Beta links u links to neighbor of v. The power-law degree exponent is -1/(1-Beta). See: Stochastic models for the web graph. Kumar, Raghavan, Rajagopalan, Sivakumar, Tomkins, Upfal. URL: http://snap.stanford.edu/class/cs224w-readings/kumar00stochastic.pdf

Definition at line 456 of file ggen.cpp.

                                                                      {
  PNGraph GraphPt = TNGraph::New();
  TNGraph& Graph = *GraphPt;
  Graph.Reserve(Nodes, Nodes);
  const int startNId = Graph.AddNode();
  Graph.AddEdge(startNId, startNId);
  for (int n = 1; n < Nodes; n++) {
    const int rnd = Graph.GetRndNId();
    const int NId = Graph.AddNode();
    if (Rnd.GetUniDev() < Beta) {
      Graph.AddEdge(NId, rnd); }
    else {
      const TNGraph::TNodeI NI = Graph.GetNI(rnd);
      const int rnd2 = Rnd.GetUniDevInt(NI.GetOutDeg());
      Graph.AddEdge(NId, NI.GetOutNId(rnd2));
    }
  }
  return GraphPt;
}

PUNGraph TSnap::GenDegSeq	(	const TIntV &	DegSeqV,
		TRnd &	Rnd
	)

Generates a random graph with exact degree sequence.

Generates a random graph with exact degree sequence DegSeqV. DegSeqV must be sorted in descending order. The generated graph has no self loops. The graph generation process simulates the Configuration Model, but if a duplicate edge occurs, we find a random edge, break it and reconnect it with the duplicate.

Definition at line 61 of file ggen.cpp.

                                                    {
  const int Nodes = DegSeqV.Len();
  PUNGraph GraphPt = TUNGraph::New();
  TUNGraph& Graph = *GraphPt;
  Graph.Reserve(Nodes, -1);
  TIntH DegH(DegSeqV.Len(), true);
  
  IAssertR(DegSeqV.IsSorted(false), "DegSeqV must be sorted in descending order.");
  int DegSum=0, edge=0;
  for (int node = 0; node < Nodes; node++) {
    IAssert(Graph.AddNode(node) == node);
    DegH.AddDat(node, DegSeqV[node]);
    DegSum += DegSeqV[node];
  }
  IAssert(DegSum % 2 == 0);
  while (! DegH.Empty()) {
    // pick random nodes and connect
    const int NId1 = DegH.GetKey(DegH.GetRndKeyId(Rnd, 0.5));
    const int NId2 = DegH.GetKey(DegH.GetRndKeyId(Rnd, 0.5));
    IAssert(DegH.IsKey(NId1) && DegH.IsKey(NId2));
    if (NId1 == NId2) {
      if (DegH.GetDat(NId1) == 1) { continue; }
      // find rnd edge, break it, and connect the endpoints to the nodes
      const TIntPr Edge = TSnapDetail::GetRndEdgeNonAdjNode(GraphPt, NId1, -1);
      if (Edge.Val1==-1) { continue; }
      Graph.DelEdge(Edge.Val1, Edge.Val2);
      Graph.AddEdge(Edge.Val1, NId1);
      Graph.AddEdge(NId1, Edge.Val2);
      if (DegH.GetDat(NId1) == 2) { DegH.DelKey(NId1); }
      else { DegH.GetDat(NId1) -= 2; }
    } else {
      if (! Graph.IsEdge(NId1, NId2)) {
        Graph.AddEdge(NId1, NId2); }  // good edge
      else {
        // find rnd edge, break and cross-connect
        const TIntPr Edge = TSnapDetail::GetRndEdgeNonAdjNode(GraphPt, NId1, NId2);
        if (Edge.Val1==-1) { continue; }
        Graph.DelEdge(Edge.Val1, Edge.Val2);
        Graph.AddEdge(NId1, Edge.Val1);
        Graph.AddEdge(NId2, Edge.Val2);
      }
      if (DegH.GetDat(NId1)==1) { DegH.DelKey(NId1); }
      else { DegH.GetDat(NId1) -= 1; }
      if (DegH.GetDat(NId2)==1) { DegH.DelKey(NId2); }
      else { DegH.GetDat(NId2) -= 1; }
    }
    if (++edge % 1000 == 0) {
      printf("\r %dk / %dk", edge/1000, DegSum/2000); }
  }
  return GraphPt;
}

PNGraph TSnap::GenForestFire	(	const int &	Nodes,
		const double &	FwdProb,
		const double &	BckProb
	)

Generates a random Forest Fire, directed graph with given probabilities.

Definition at line 445 of file ggen.cpp.

                                                                                      {
  return TForestFire::GenGraph(Nodes, FwdProb, BckProb);
}

template<class PGraph >

PGraph TSnap::GenFull

(

const int &

Nodes

)

Generates a complete graph on Nodes nodes. Graph has no self-loops.

Definition at line 119 of file ggen.h.

                                 {
  PGraph Graph = PGraph::TObj::New();
  Graph->Reserve(Nodes, Nodes*Nodes);
  for (int n = 0; n < Nodes; n++) {
    Graph->AddNode(n); }
  for (int n1 = 0; n1 < Nodes; n1++) {
    for (int n2 = 0; n2 < Nodes; n2++) {
      if (n1 != n2) { Graph->AddEdge(n1, n2); }
    }
  }
  return Graph;
}

PUNGraph TSnap::GenGeoPrefAttach	(	const int &	Nodes,
		const int &	OutDeg,
		const double &	Beta,
		TRnd &	Rnd
	)

Generates a random scale-free graph using the Geometric Preferential model.

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

Definition at line 364 of file ggen.cpp.

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

template<class PGraph >

PGraph TSnap::GenGrid	(	const int &	Rows,
		const int &	Cols,
		const bool &	IsDir = true
	)

Generates a 2D-grid graph of Rows rows and Cols columns.

Definition at line 65 of file ggen.h.

                                                                    {
  PGraph GraphPt = PGraph::New();
  typename PGraph::TObj& Graph = *GraphPt;
  Graph.Reserve(Rows*Cols, 4*Rows*Cols);
  int node, r, c;
  for (node = 0; node < Rows * Cols; node++) {
    Graph.AddNode(node); }
  for (r = 0; r < Rows; r++) {
    for (c = 0; c < Cols; c++) {
      const int nodeId = Cols*r + c;
      if (r < Rows-1) { // bottom node
        Graph.AddEdge(nodeId, nodeId+Cols); 
        if (Graph.HasFlag(gfDirected) && ! IsDir) { 
          Graph.AddEdge(nodeId+Cols, nodeId); }
      }
      if (c < Cols-1) { // right node
        Graph.AddEdge(nodeId, nodeId+1); 
        if (Graph.HasFlag(gfDirected) && ! IsDir) { 
          Graph.AddEdge(nodeId+1, nodeId); }
      }
    }
  }
  return GraphPt;
}

PUNGraph TSnap::GenPrefAttach	(	const int &	Nodes,
		const int &	NodeOutDeg,
		TRnd &	Rnd
	)

Generates a power-law degree distribution using Barabasi-Albert model of scale-free graphs.

Barabasi-Albert model of scale-free graphs. The graph has power-law degree distribution. See: Emergence of scaling in random networks by Barabasi and Albert. URL: http://arxiv.org/abs/cond-mat/9910332

Definition at line 313 of file ggen.cpp.

                                                                           {
  PUNGraph GraphPt = PUNGraph::New();
  TUNGraph& Graph = *GraphPt;
  Graph.Reserve(Nodes, NodeOutDeg*Nodes);
  TIntV NIdV(NodeOutDeg*Nodes, 0);
  // first edge
  Graph.AddNode(0);  Graph.AddNode(1);
  NIdV.Add(0);  NIdV.Add(1);
  Graph.AddEdge(0, 1);
  TIntSet NodeSet;
  for (int node = 2; node < Nodes; node++) {
    NodeSet.Clr(false);
    while (NodeSet.Len() < NodeOutDeg && NodeSet.Len() < node) {
      NodeSet.AddKey(NIdV[Rnd.GetUniDevInt(NIdV.Len())]);
    }
    const int N = Graph.AddNode();
    for (int i = 0; i < NodeSet.Len(); i++) {
      Graph.AddEdge(N, NodeSet[i]);
      NIdV.Add(N);
      NIdV.Add(NodeSet[i]);
    }
  }
  return GraphPt;
}

PUNGraph TSnap::GenRewire	(	const PUNGraph &	OrigGraph,
		const int &	NSwitch,
		TRnd &	Rnd
	)

Rewire a random undirected graph. Keeps node degrees the same, but randomly rewires the edges.

Rewire the network. Keeps node degrees as is but randomly rewires the edges. Use this function to generate a random graph with the same degree sequence as the OrigGraph. See: On the uniform generation of random graphs with prescribed degree sequences by R. Milo, N. Kashtan, S. Itzkovitz, M. E. J. Newman, U. Alon URL: http://arxiv.org/abs/cond-mat/0312028

Definition at line 168 of file ggen.cpp.

                                                                             {
  const int Nodes = OrigGraph->GetNodes();
  const int Edges = OrigGraph->GetEdges();
  PUNGraph GraphPt = TUNGraph::New();
  TUNGraph& Graph = *GraphPt;
  Graph.Reserve(Nodes, -1);
  TExeTm ExeTm;
  // generate a graph that satisfies the constraints
  printf("Randomizing edges (%d, %d)...\n", Nodes, Edges);
  TIntPrSet EdgeSet(Edges);
  for (TUNGraph::TNodeI NI = OrigGraph->BegNI(); NI < OrigGraph->EndNI(); NI++) {
    const int NId = NI.GetId();
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      if (NId <= NI.GetOutNId(e)) { continue; }
      EdgeSet.AddKey(TIntPr(NId, NI.GetOutNId(e)));
    }
    Graph.AddNode(NI.GetId());
  }
  // edge switching
  uint skip=0;
  for (uint swps = 0; swps < 2*uint(Edges)*uint(NSwitch); swps++) {
    const int keyId1 = EdgeSet.GetRndKeyId(Rnd);
    const int keyId2 = EdgeSet.GetRndKeyId(Rnd);
    if (keyId1 == keyId2) { skip++; continue; }
    const TIntPr& E1 = EdgeSet[keyId1];
    const TIntPr& E2 = EdgeSet[keyId2];
    TIntPr NewE1(E1.Val1, E2.Val1), NewE2(E1.Val2, E2.Val2);
    if (NewE1.Val1 > NewE1.Val2) { Swap(NewE1.Val1, NewE1.Val2); }
    if (NewE2.Val1 > NewE2.Val2) { Swap(NewE2.Val1, NewE2.Val2); }
    if (NewE1!=NewE2 && NewE1.Val1!=NewE1.Val2 && NewE2.Val1!=NewE2.Val2 && ! EdgeSet.IsKey(NewE1) && ! EdgeSet.IsKey(NewE2)) {
      EdgeSet.DelKeyId(keyId1);  EdgeSet.DelKeyId(keyId2);
      EdgeSet.AddKey(TIntPr(NewE1));
      EdgeSet.AddKey(TIntPr(NewE2));
    } else { skip++; }
    if (swps % Edges == 0) {
      printf("\r  %uk/%uk: %uk skip [%s]", swps/1000u, 2*uint(Edges)*uint(NSwitch)/1000u, skip/1000u, ExeTm.GetStr());
      if (ExeTm.GetSecs() > 2*3600) { printf(" *** Time limit!\n"); break; } // time limit 2 hours
    }
  }
  printf("\r  total %uk switchings attempted, %uk skiped  [%s]\n", 2*uint(Edges)*uint(NSwitch)/1000u, skip/1000u, ExeTm.GetStr());
  for (int e = 0; e < EdgeSet.Len(); e++) {
    Graph.AddEdge(EdgeSet[e].Val1, EdgeSet[e].Val2); }
  return GraphPt;
}

PNGraph TSnap::GenRewire	(	const PNGraph &	OrigGraph,
		const int &	NSwitch,
		TRnd &	Rnd
	)

Rewire a random directed graph. Keeps node degrees the same, but randomly rewires the edges.

Rewire the network. Keeps node degrees as is but randomly rewires the edges. Use this function to generate a random graph with the same degree sequence as the OrigGraph. See: On the uniform generation of random graphs with prescribed degree sequences by R. Milo, N. Kashtan, S. Itzkovitz, M. E. J. Newman, U. Alon. URL: http://arxiv.org/abs/cond-mat/0312028

Definition at line 219 of file ggen.cpp.

                                                                           {
  const int Nodes = OrigGraph->GetNodes();
  const int Edges = OrigGraph->GetEdges();
  PNGraph GraphPt = TNGraph::New();
  TNGraph& Graph = *GraphPt;
  Graph.Reserve(Nodes, -1);
  TExeTm ExeTm;
  // generate a graph that satisfies the constraints
  printf("Randomizing edges (%d, %d)...\n", Nodes, Edges);
  TIntPrSet EdgeSet(Edges);
  for (TNGraph::TNodeI NI = OrigGraph->BegNI(); NI < OrigGraph->EndNI(); NI++) {
    const int NId = NI.GetId();
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      EdgeSet.AddKey(TIntPr(NId, NI.GetOutNId(e))); }
    Graph.AddNode(NI);
  }
  // edge switching
  uint skip=0;
  for (uint swps = 0; swps < 2*uint(Edges)*uint(NSwitch); swps++) {
    const int keyId1 = EdgeSet.GetRndKeyId(Rnd);
    const int keyId2 = EdgeSet.GetRndKeyId(Rnd);
    if (keyId1 == keyId2) { skip++; continue; }
    const TIntPr& E1 = EdgeSet[keyId1];
    const TIntPr& E2 = EdgeSet[keyId2];
    TIntPr NewE1(E1.Val1, E2.Val2), NewE2(E2.Val1, E1.Val2);
    if (NewE1.Val1!=NewE1.Val2 && NewE2.Val1!=NewE2.Val2 && NewE1.Val1!=NewE2.Val1 && NewE1.Val2!=NewE2.Val2 && ! EdgeSet.IsKey(NewE1) && ! EdgeSet.IsKey(NewE2)) {
      EdgeSet.DelKeyId(keyId1);  EdgeSet.DelKeyId(keyId2);
      EdgeSet.AddKey(TIntPr(NewE1));
      EdgeSet.AddKey(TIntPr(NewE2));
    } else { skip++; }
    if (swps % Edges == 0) {
      printf("\r  %uk/%uk: %uk skip [%s]", swps/1000u, 2*uint(Edges)*uint(NSwitch)/1000u, skip/1000u, ExeTm.GetStr());
      if (ExeTm.GetSecs() > 2*3600) { printf(" *** Time limit!\n"); break; } // time limit 2 hours
    }
  }
  printf("\r  total %uk switchings attempted, %uk skiped  [%s]\n", 2*uint(Edges)*uint(NSwitch)/1000u, skip/1000u, ExeTm.GetStr());
  for (int e = 0; e < EdgeSet.Len(); e++) {
    Graph.AddEdge(EdgeSet[e].Val1, EdgeSet[e].Val2); }
  return GraphPt;
}

PBPGraph TSnap::GenRewire	(	const PBPGraph &	OrigGraph,
		const int &	NSwitch,
		TRnd &	Rnd
	)

Rewire a random bipartite graph. Keeps node degrees the same, but randomly rewires the edges.

Rewire a bipartite graph. Keeps node degrees as is but randomly rewires the edges. Use this function to generate a random graph with the same degree sequence as the OrigGraph. See: On the uniform generation of random graphs with prescribed degree sequences by R. Milo, N. Kashtan, S. Itzkovitz, M. E. J. Newman, U. Alon URL: http://arxiv.org/abs/cond-mat/0312028

Definition at line 266 of file ggen.cpp.

                                                                             {
  const int Nodes = OrigGraph->GetNodes();
  const int Edges = OrigGraph->GetEdges();
  PBPGraph GraphPt = TBPGraph::New();
  TBPGraph& Graph = *GraphPt;
  Graph.Reserve(Nodes, -1);
  TExeTm ExeTm;
  // generate a graph that satisfies the constraints
  printf("Randomizing edges (%d, %d)...\n", Nodes, Edges);
  TIntPrSet EdgeSet(Edges);
  for (TBPGraph::TNodeI NI = OrigGraph->BegLNI(); NI < OrigGraph->EndLNI(); NI++) {
    const int NId = NI.GetId();
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      EdgeSet.AddKey(TIntPr(NId, NI.GetOutNId(e))); } // edges left-->right
    Graph.AddNode(NI.GetId(), true); } // left nodes
  for (TBPGraph::TNodeI NI = OrigGraph->BegRNI(); NI < OrigGraph->EndRNI(); NI++) {
    Graph.AddNode(NI.GetId(), false); } // right nodes
  IAssert(EdgeSet.Len() == Edges);
  // edge switching
  uint skip=0;
  for (uint swps = 0; swps < 2*uint(Edges)*uint(NSwitch); swps++) {
    const int keyId1 = EdgeSet.GetRndKeyId(Rnd);
    const int keyId2 = EdgeSet.GetRndKeyId(Rnd);
    if (keyId1 == keyId2) { skip++; continue; }
    const TIntPr& E1 = EdgeSet[keyId1];
    const TIntPr& E2 = EdgeSet[keyId2];
    TIntPr NewE1(E1.Val1, E2.Val2), NewE2(E2.Val1, E1.Val2);
    if (NewE1!=NewE2 && NewE1.Val1!=NewE1.Val2 && NewE2.Val1!=NewE2.Val2 && ! EdgeSet.IsKey(NewE1) && ! EdgeSet.IsKey(NewE2)) {
      EdgeSet.DelKeyId(keyId1);  EdgeSet.DelKeyId(keyId2);
      EdgeSet.AddKey(TIntPr(NewE1));
      EdgeSet.AddKey(TIntPr(NewE2));
    } else { skip++; }
    if (swps % Edges == 0) {
      printf("\r  %uk/%uk: %uk skip [%s]", swps/1000u, 2*uint(Edges)*uint(NSwitch)/1000u, skip/1000u, ExeTm.GetStr());
      if (ExeTm.GetSecs() > 2*3600) { printf(" *** Time limit!\n"); break; } // time limit 2 hours
    }
  }
  printf("\r  total %uk switchings attempted, %uk skiped  [%s]\n", 2*uint(Edges)*uint(NSwitch)/1000u, skip/1000u, ExeTm.GetStr());
  for (int e = 0; e < EdgeSet.Len(); e++) {
    Graph.AddEdge(EdgeSet[e].Val1, EdgeSet[e].Val2); }
  return GraphPt;
}

PNGraph TSnap::GenRMat	(	const int &	Nodes,
		const int &	Edges,
		const double &	A,
		const double &	B,
		const double &	C,
		TRnd &	Rnd
	)

Generates a R-MAT graph using recursive descent into a 2x2 matrix [A,B; C, 1-(A+B+C)].

R-MAT Generator. The modes is based on the recursive descent into a 2x2 matrix [A,B; C, 1-(A+B+C)]. See: R-MAT Generator: A Recursive Model for Graph Mining. D. Chakrabarti, Y. Zhan and C. Faloutsos, in SIAM Data Mining 2004. URL: http://www.cs.cmu.edu/~deepay/mywww/papers/siam04.pdf

Definition at line 481 of file ggen.cpp.

                                                                                                                  {
  PNGraph GraphPt = TNGraph::New();
  TNGraph& Graph = *GraphPt;
  Graph.Reserve(Nodes, Edges);
  IAssert(A+B+C < 1.0);
  int rngX, rngY, offX, offY;
  int Depth=0, Collisions=0, Cnt=0, PctDone=0;
  const int EdgeGap = Edges / 100 + 1;
  // sum of parameters (probabilities)
  TVec<double> sumA(128, 0), sumAB(128, 0), sumAC(128, 0), sumABC(128, 0);  // up to 2^128 vertices ~ 3.4e38
  for (int i = 0; i < 128; i++) {
    const double a = A * (Rnd.GetUniDev() + 0.5);
    const double b = B * (Rnd.GetUniDev() + 0.5);
    const double c = C * (Rnd.GetUniDev() + 0.5);
    const double d = (1.0 - (A+B+C)) * (Rnd.GetUniDev() + 0.5);
    const double abcd = a+b+c+d;
    sumA.Add(a / abcd);
    sumAB.Add((a+b) / abcd);
    sumAC.Add((a+c) / abcd);
    sumABC.Add((a+b+c) / abcd);
  }
  // nodes
  for (int node = 0; node < Nodes; node++) {
    IAssert(Graph.AddNode(-1) == node);
  }
  // edges
  for (int edge = 0; edge < Edges; ) {
    rngX = Nodes;  rngY = Nodes;  offX = 0;  offY = 0;
    Depth = 0;
    // recurse the matrix
    while (rngX > 1 || rngY > 1) {
      const double RndProb = Rnd.GetUniDev();
      if (rngX>1 && rngY>1) {
        if (RndProb < sumA[Depth]) { rngX/=2; rngY/=2; }
        else if (RndProb < sumAB[Depth]) { offX+=rngX/2;  rngX-=rngX/2;  rngY/=2; }
        else if (RndProb < sumABC[Depth]) { offY+=rngY/2;  rngX/=2;  rngY-=rngY/2; }
        else { offX+=rngX/2;  offY+=rngY/2;  rngX-=rngX/2;  rngY-=rngY/2; }
      } else
      if (rngX>1) { // row vector
        if (RndProb < sumAC[Depth]) { rngX/=2; rngY/=2; }
        else { offX+=rngX/2;  rngX-=rngX/2;  rngY/=2; }
      } else
      if (rngY>1) { // column vector
        if (RndProb < sumAB[Depth]) { rngX/=2; rngY/=2; }
        else { offY+=rngY/2;  rngX/=2;  rngY-=rngY/2; }
      } else { Fail; }
      Depth++;
    }
    // add edge
    const int NId1 = offX;
    const int NId2 = offY;
    if (NId1 != NId2 && ! Graph.IsEdge(NId1, NId2)) {
      Graph.AddEdge(NId1, NId2);
      if (++Cnt > EdgeGap) {
        Cnt=0;  printf("\r  %d%% edges", ++PctDone); }
      edge++;
    } else {
      Collisions++; }
  }
  printf("\r  RMat: nodes:%d, edges:%d, Iterations:%d, Collisions:%d (%.1f%%).\n", Nodes, Edges,
    Edges+Collisions, Collisions, 100*Collisions/double(Edges+Collisions));
  Graph.Defrag();
  return GraphPt;
}

PNGraph TSnap::GenRMatEpinions

(

)

Generates a R-Mat graph, with a synthetic copy of the Epinions social network.

R-Mat generator with parameters set so that it generates a synthetic copy of the Epinions social network. The original Epinions social network can be downloaded at http://snap.stanford.edu/data/soc-Epinions1.html

Definition at line 550 of file ggen.cpp.

                          {
  return GenRMat(75888, 508837, 0.550, 0.228, 0.212);
}

PBPGraph TSnap::GenRndBipart	(	const int &	LeftNodes,
		const int &	RightNodes,
		const int &	Edges,
		TRnd &	Rnd
	)

Generates a random bipartite graph.

Definition at line 5 of file ggen.cpp.

                                                                                                {
  PBPGraph G = TBPGraph::New();
  for (int i = 0; i < LeftNodes; i++) { G->AddNode(i, true); }
  for (int i = 0; i < RightNodes; i++) { G->AddNode(LeftNodes+i, false); }
  IAssertR(Edges <= LeftNodes*RightNodes, "Too many edges in the bipartite graph!");
  for (int edges = 0; edges < Edges; ) {
    const int LNId = Rnd.GetUniDevInt(LeftNodes);
    const int RNId = LeftNodes + Rnd.GetUniDevInt(RightNodes);
    if (G->AddEdge(LNId, RNId) != -2) { edges++; } // is new edge
  }
  return G;
}

PUNGraph TSnap::GenRndDegK	(	const int &	Nodes,
		const int &	NodeDeg,
		const int &	NSwitch,
		TRnd &	Rnd
	)

Generates a random graph where each node has degree exactly NodeDeg.

Definition at line 18 of file ggen.cpp.

                                                                                         {
  // create degree sequence
  TIntV DegV(Nodes, 0);
  int DegSum=0;
  for (int i = 0; i < Nodes; i++) {
    DegV.Add(NodeDeg);
    DegSum += NodeDeg;
  }
  IAssert(DegSum % 2 == 0);
  PUNGraph G = GenDegSeq(DegV, Rnd); // get some graph that obeys the degree sequnce
  return GenRewire(G, NSwitch, Rnd);  // make it random
}

template<class PGraph >

PGraph TSnap::GenRndGnm	(	const int &	Nodes,
		const int &	Edges,
		const bool &	IsDir = true,
		TRnd &	Rnd = TInt::Rnd
	)

Generates an Erdos-Renyi random graph.

Definition at line 218 of file ggen.h.

                                                                                   {
  PGraph GraphPt = PGraph::New();
  typename PGraph::TObj& Graph = *GraphPt;
  Graph.Reserve(Nodes, Edges);
  IAssertR((1.0 * (Nodes-1) / 2 * (IsDir ? 2 : 1)) >= (1.0 * Edges / Nodes), TStr::Fmt("Not enough nodes (%d), for edges (%d).", Nodes, Edges));
  for (int node = 0; node < Nodes; node++) {
    IAssert(Graph.AddNode(node) == node);
  }
  for (int edge = 0; edge < Edges; ) {
    const int SrcNId = Rnd.GetUniDevInt(Nodes);
    const int DstNId = Rnd.GetUniDevInt(Nodes);
    if (SrcNId != DstNId && Graph.AddEdge(SrcNId, DstNId) != -2) { // is new edge
      if (! IsDir) { Graph.AddEdge(DstNId, SrcNId); }
      edge++;
    }
  }
  return GraphPt;
}

PUNGraph TSnap::GenRndPowerLaw	(	const int &	Nodes,
		const double &	PowerExp,
		const bool &	ConfModel,
		TRnd &	Rnd
	)

Generates a random scale-free graph with power-law degree distribution.

Generates a random scale-free graph with power-law degree distribution with exponent PowerExp. The method uses either the Configuration model (fast but the result is approximate) or the Edge Rewiring method (slow but exact).

Definition at line 34 of file ggen.cpp.

                                                                                                    {
  TIntV DegSeqV;
  uint DegSum=0;
  for (int n = 0; n < Nodes; n++) {
    const int Val = (int) TMath::Round(Rnd.GetPowerDev(PowerExp));
    if (! (Val >= 1 && Val < Nodes/2)) { n--; continue; } // skip nodes with too large degree
    DegSeqV.Add(Val);
    DegSum += Val;
  }
  printf("%d nodes, %u edges\n", Nodes, DegSum);
  if (DegSum % 2 == 1) { DegSeqV[0] += 1; }
  if (ConfModel) {
    // use configuration model -- fast but does not exactly obey the degree sequence
    return GenConfModel(DegSeqV, Rnd);
  } else {
    DegSeqV.Sort();
    DegSeqV.Reverse();
    PUNGraph G = TSnap::GenDegSeq(DegSeqV, Rnd);
    return TSnap::GenRewire(G, 10, Rnd);
  }
}

PUNGraph TSnap::GenSmallWorld	(	const int &	Nodes,
		const int &	NodeOutDeg,
		const double &	RewireProb,
		TRnd &	Rnd
	)

Generates a randomly small-world graph using the Watts-Strogatz model.

Generates a small-world graph using the Watts-Strogatz model. We assume a circle where each node creates links to NodeOutDeg other nodes. This way at the end each node is connected to 2*NodeOutDeg other nodes. See: Collective dynamics of 'small-world' networks. Watts and Strogatz. URL: http://research.yahoo.com/files/w_s_NATURE_0.pdf

Definition at line 415 of file ggen.cpp.

                                                                                                     {
  THashSet<TIntPr> EdgeSet(Nodes*NodeOutDeg);
  
  IAssertR(Nodes > NodeOutDeg, TStr::Fmt("Insufficient nodes for out degree, %d!", NodeOutDeg));
  for (int node = 0; node < Nodes; node++) {
    const int src = node;
    for (int edge = 1; edge <= NodeOutDeg; edge++) {
      int dst = (node+edge) % Nodes;      // edge to next neighbor
      if (Rnd.GetUniDev() < RewireProb) { // random edge
        dst = Rnd.GetUniDevInt(Nodes);
        while (dst == src || EdgeSet.IsKey(TIntPr(src, dst))) {
          dst = Rnd.GetUniDevInt(Nodes); }
      }
      EdgeSet.AddKey(TIntPr(src, dst));
    }
  }
  PUNGraph GraphPt = TUNGraph::New();
  TUNGraph& Graph = *GraphPt;
  Graph.Reserve(Nodes, EdgeSet.Len());
  int node;
  for (node = 0; node < Nodes; node++) {
    IAssert(Graph.AddNode(node) == node);
  }
  for (int edge = 0; edge < EdgeSet.Len(); edge++) {
    Graph.AddEdge(EdgeSet[edge].Val1, EdgeSet[edge].Val2);
  }
  Graph.Defrag();
  return GraphPt;
}

template<class PGraph >

PGraph TSnap::GenStar	(	const int &	Nodes,
		const bool &	IsDir = true
	)

Generates a graph with star topology. Node id 0 is in the center and then links to all other nodes.

Definition at line 91 of file ggen.h.

                                                    {
  PGraph Graph = PGraph::TObj::New();
  Graph->Reserve(Nodes, Nodes);
  Graph->AddNode(0);
  for (int n = 1; n < Nodes; n++) {
    Graph->AddNode(n);
    Graph->AddEdge(0, n);
    if (Graph->HasFlag(gfDirected) && ! IsDir) { Graph->AddEdge(n, 0); }
  }
  return Graph;
}

template<class PGraph >

PGraph TSnap::GenTree	(	const int &	Fanout,
		const int &	Levels,
		const bool &	IsDir = true,
		const bool &	ChildPointsToParent = true
	)

Generates a tree graph of Levels levels with every parent having Fanout children.

Definition at line 133 of file ggen.h.

                                                                                                         {
  const int Nodes = (int) (pow(double(Fanout), double(Levels+1)) - 1) / (Fanout - 1);
  const int Edges = Nodes - 1;
  PGraph GraphPt = PGraph::New();
  typename PGraph::TObj& Graph = *GraphPt;
  Graph.Reserve(Nodes, Edges);
  int node;
  for (node = 0; node < Nodes; node++) {
    Graph.AddNode(node); }
  // non-leaf nodes
  for (node = 0; node < (int) Nodes - (int) pow(double(Fanout), double(Levels)); node++) {
    for (int edge = 1; edge <= Fanout; edge++) {
      if (IsDir) {
        if (ChildPointsToParent) { Graph.AddEdge(Fanout*node+edge, node); }
        else { Graph.AddEdge(node, Fanout*node+edge); }
      } else {
        Graph.AddEdge(node, Fanout*node+edge); // link children
        Graph.AddEdge(Fanout*node+edge, node);
      }
    }
  }
  return GraphPt;
}

void TSnap::Get1CnCom	(	const PUNGraph &	Graph,
		TCnComV &	Cn1ComV
	)

Returns 1-components: maximal connected components of that can be disconnected from the Graph by removing a single edge.

We find such components as follows: Find all bridge edges, remove them from the Graph, find largest component K and add back all bridges that do not touch K. Now, find the connected components of this graph.

Definition at line 98 of file cncom.cpp.

                                                        {
  //TCnCom::GetWccCnt(Graph, SzCntV);  IAssertR(SzCntV.Len() == 1, "Graph is not connected.");
  TIntPrV EdgeV;
  GetEdgeBridges(Graph, EdgeV);
  if (EdgeV.Empty()) { Cn1ComV.Clr(false); return; }
  PUNGraph TmpG = TUNGraph::New();
  *TmpG = *Graph;
  for (int e = 0; e < EdgeV.Len(); e++) {
    TmpG->DelEdge(EdgeV[e].Val1, EdgeV[e].Val2);  }
  TCnComV CnComV;  GetWccs(TmpG, CnComV);
  IAssert(CnComV.Len() >= 2);
  const TIntV& MxWcc = CnComV[0].NIdV;
  TIntSet MxCcSet(MxWcc.Len());
  for (int i = 0; i < MxWcc.Len(); i++) { 
    MxCcSet.AddKey(MxWcc[i]); }
  // create new graph: bridges not touching MxCc of G with no bridges
  for (int e = 0; e < EdgeV.Len(); e++) {
    if (! MxCcSet.IsKey(EdgeV[e].Val1) &&  ! MxCcSet.IsKey(EdgeV[e].Val2)) {
      TmpG->AddEdge(EdgeV[e].Val1, EdgeV[e].Val2); }
  }
  GetWccs(TmpG, Cn1ComV);
  // remove the largest component of G
  for (int c = 0; c < Cn1ComV.Len(); c++) {
    if (MxCcSet.IsKey(Cn1ComV[c].NIdV[0])) {
      Cn1ComV.Del(c);  break; }
  }
}

void TSnap::Get1CnComSzCnt	(	const PUNGraph &	Graph,
		TIntPrV &	SzCntV
	)

Distribution of sizes of 1-components, maximal number of components that can be disconnected from the Graph by removing a single edge.

We find such components as follows: Find all bridge edges, remove them from the Graph, find largest component K and add back all bridges that do not touch K. Now, find the connected components of this graph.

Definition at line 70 of file cncom.cpp.

                                                            {
  //TCnCom::GetWccCnt(Graph, SzCntV);  IAssertR(SzCntV.Len() == 1, "Graph is not connected.");
  TIntPrV EdgeV;
  GetEdgeBridges(Graph, EdgeV);
  if (EdgeV.Empty()) { SzCntV.Clr(false); return; }
  PUNGraph TmpG = TUNGraph::New();
  *TmpG = *Graph;
  for (int e = 0; e < EdgeV.Len(); e++) {
    TmpG->DelEdge(EdgeV[e].Val1, EdgeV[e].Val2);  }
  TCnComV CnComV;  GetWccs(TmpG, CnComV);
  IAssert(CnComV.Len() >= 2);
  const TIntV& MxWcc = CnComV[0].NIdV;
  TIntSet MxCcSet(MxWcc.Len());
  for (int i = 0; i < MxWcc.Len(); i++) { 
    MxCcSet.AddKey(MxWcc[i]); }
  // create new graph: bridges not touching MxCc of G with no bridges
  for (int e = 0; e < EdgeV.Len(); e++) {
    if (! MxCcSet.IsKey(EdgeV[e].Val1) &&  ! MxCcSet.IsKey(EdgeV[e].Val2)) {
      TmpG->AddEdge(EdgeV[e].Val1, EdgeV[e].Val2); }
  }
  GetWccSzCnt(TmpG, SzCntV);
  for (int c = 0; c < SzCntV.Len(); c++) {
    if (SzCntV[c].Val1 == MxCcSet.Len()) { 
      SzCntV.Del(c);  break; }
  }
}

template<class PGraph >

void TSnap::GetAnf	(	const PGraph &	Graph,
		const int &	SrcNId,
		TIntFltKdV &	DistNbrsV,
		const int &	MxDist,
		const bool &	IsDir,
		const int &	NApprox = 32
	)

Approximate Neighborhood Function of a node: Returns the (approximate) number of nodes reachable from SrcNId in less than H hops.

Parameters

SrcNId	Starting node.
DistNbrsV	Maps between the distance H (in hops) and the number of nodes reachable in <=H hops.
MxDist	Maximum number of hops the algorithm spreads from SrcNId.
IsDir	false: consider links as undirected (drop link directions).
NApprox	Quality of approximation. See the ANF paper.

Definition at line 204 of file anf.h.

                                                                                                                                     {
  TGraphAnf<PGraph> Anf(Graph, NApprox, 5, 0);
  Anf.GetNodeAnf(SrcNId, DistNbrsV, MxDist, IsDir);
}

template<class PGraph >

void TSnap::GetAnf	(	const PGraph &	Graph,
		TIntFltKdV &	DistNbrsV,
		const int &	MxDist,
		const bool &	IsDir,
		const int &	NApprox = 32
	)

Approximate Neighborhood Function of a Graph: Returns the number of pairs of nodes reachable in less than H hops. For example, DistNbrsV.GetDat(0) is the number of nodes in the graph, DistNbrsV.GetDat(1) is the number of nodes+edges and so on.

Parameters

DistNbrsV	Maps between the distance H (in hops) and the number of nodes reachable in <=H hops.
MxDist	Maximum number of hops the algorithm spreads from SrcNId.
IsDir	false: consider links as undirected (drop link directions).
NApprox	Quality of approximation. See the ANF paper.

Definition at line 210 of file anf.h.

                                                                                                                  {
  TGraphAnf<PGraph> Anf(Graph, NApprox, 5, 0);
  Anf.GetGraphAnf(DistNbrsV, MxDist, IsDir);
}

template<class PGraph >

double TSnap::GetAnfEffDiam	(	const PGraph &	Graph,
		const bool &	IsDir,
		const double &	Percentile,
		const int &	NApprox
	)

Returns a given Percentile of the shortest path length distribution of a Graph (based on a single run of ANF of approximation quality NApprox).

Parameters

IsDir

false: consider links as undirected (drop link directions).

Definition at line 216 of file anf.h.

                                                                                                           {
  TIntFltKdV DistNbrsV;
  TGraphAnf<PGraph> Anf(Graph, NApprox, 5, 0);
  Anf.GetGraphAnf(DistNbrsV, -1, IsDir);
  return TSnap::TSnapDetail::CalcEffDiam(DistNbrsV, Percentile);
}

template<class PGraph >

double TSnap::GetAnfEffDiam	(	const PGraph &	Graph,
		const int	NRuns = 1,
		int	NApprox = -1
	)

Returns a 90-th percentile of the shortest path length distribution of a Graph (based on a NRuns runs of ANF of approximation quality NApprox).

Parameters

IsDir

false: consider links as undirected (drop link directions).

Definition at line 224 of file anf.h.

                                                                        {
  //return TSnap::GetEffDiam(Graph, IsDir, 0.9, 32);
  TMom Mom;
  if (NApprox == -1) {
    if (Graph->GetNodes() < 100000) { NApprox = 64; }
    else if (Graph->GetNodes() < 1000000) { NApprox = 32; }
    else { NApprox = 16; }
  }
  const bool IsDir = false;
  for (int r = 0; r < NRuns; r++) {
    Mom.Add(TSnap::GetAnfEffDiam(Graph, IsDir, 0.9, NApprox));
  }
  Mom.Def();
  return Mom.GetMean();
}

void TSnap::GetArtPoints	(	const PUNGraph &	Graph,
		TIntV &	ArtNIdV
	)

Returns articulation points of a Graph.

Articulation point (or a cut vertex) is any node that when removed increases the number of connected components.

Definition at line 48 of file cncom.cpp.

                                                         {
  TArtPointVisitor Visitor(Graph->GetNodes());
  TCnCom::GetDfsVisitor(Graph, Visitor);
  Visitor.ArtSet.GetKeyV(ArtNIdV);
}

template<class PGraph >

void TSnap::GetBetweennessCentr	(	const PGraph &	Graph,
		TIntFltH &	NIdBtwH,
		const double &	NodeFrac = 1.0,
		const bool &	IsDir = false
	)

Computes (approximate) Node Beetweenness Centrality based on a sample of NodeFrac nodes.

Parameters

NIdBtwH	hash table mapping node ids to their corresponding betweenness centrality values.
NodeFrac	quality of approximation. NodeFrac=1.0 gives exact betweenness values.

Definition at line 489 of file centr.h.

                                                                                                             {
  TIntPrFltH EdgeBtwH;
  TIntV NIdV;  Graph->GetNIdV(NIdV);
  if (NodeFrac < 1.0) { // calculate beetweenness centrality for a subset of nodes
    NIdV.Shuffle(TInt::Rnd);
    for (int i = int((1.0-NodeFrac)*NIdV.Len()); i > 0; i--) {
      NIdV.DelLast(); }
  }
  GetBetweennessCentr<PGraph> (Graph, NIdV, NodeBtwH, true, EdgeBtwH, false, IsDir);
}

template<class PGraph >

void TSnap::GetBetweennessCentr	(	const PGraph &	Graph,
		TIntPrFltH &	EdgeBtwH,
		const double &	NodeFrac = 1.0,
		const bool &	IsDir = false
	)

Computes (approximate) Edge Beetweenness Centrality based on a sample of NodeFrac nodes.

Parameters

EdgeBtwH	hash table mapping edges (pairs of node ids) to their corresponding betweenness centrality values.
NodeFrac	quality of approximation. NodeFrac=1.0 gives exact betweenness values.

Definition at line 501 of file centr.h.

                                                                                                               {
  TIntFltH NodeBtwH;
  TIntV NIdV;  Graph->GetNIdV(NIdV);
  if (NodeFrac < 1.0) { // calculate beetweenness centrality for a subset of nodes
    NIdV.Shuffle(TInt::Rnd);
    for (int i = int((1.0-NodeFrac)*NIdV.Len()); i > 0; i--) {
      NIdV.DelLast(); }
  }
  GetBetweennessCentr<PGraph> (Graph, NIdV, NodeBtwH, false, EdgeBtwH, true, IsDir);
}

template<class PGraph >

void TSnap::GetBetweennessCentr	(	const PGraph &	Graph,
		TIntFltH &	NIdBtwH,
		TIntPrFltH &	EdgeBtwH,
		const double &	NodeFrac = 1.0,
		const bool &	IsDir = false
	)

Computes (approximate) Node and Edge Beetweenness Centrality based on a sample of NodeFrac nodes.

Parameters

NIdBtwH	hash table mapping node ids to their corresponding betweenness centrality values.
EdgeBtwH	hash table mapping edges (pairs of node ids) to their corresponding betweenness centrality values.
NodeFrac	quality of approximation. NodeFrac=1.0 gives exact betweenness values.

Definition at line 513 of file centr.h.

                                                                                                                                   {
  TIntV NIdV;  Graph->GetNIdV(NIdV);
  if (NodeFrac < 1.0) { // calculate beetweenness centrality for a subset of nodes
    NIdV.Shuffle(TInt::Rnd);
    for (int i = int((1.0-NodeFrac)*NIdV.Len()); i > 0; i--) {
      NIdV.DelLast(); }
  }
  GetBetweennessCentr<PGraph> (Graph, NIdV, NodeBtwH, true, EdgeBtwH, true, IsDir);
}

template<class PGraph >

void TSnap::GetBetweennessCentr	(	const PGraph &	Graph,
		const TIntV &	BtwNIdV,
		TIntFltH &	NodeBtwH,
		const bool &	DoNodeCent,
		TIntPrFltH &	EdgeBtwH,
		const bool &	DoEdgeCent,
		const bool &	IsDir
	)

Computes (approximate) Beetweenness Centrality of all nodes and all edges of the network. To obtain exact betweenness values one needs to solve single-source shortest-path problem for every node. To speed up the algorithm we solve the shortest-path problem for the BtwNIdV subset of nodes. This gives centrality values that are about Graph->GetNodes()/BtwNIdV.Len() times lower than the exact betweenness centrality valus. See "A Faster Algorithm for Beetweenness Centrality", Ulrik Brandes, Journal of Mathematical Sociology, 2001, and "Centrality Estimation in Large Networks", Urlik Brandes and Christian Pich, 2006 for more details.

Definition at line 374 of file centr.h.

                                                                                                                                                                                 {
  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 (typename PGraph::TObj::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 (Graph->HasFlag(gfDirected) && IsDir) {
          // add all outgoing edges for directed graphs
          EdgeBtwH.AddDat(TIntPr(NI.GetId(), NI.GetOutNId(e)), 0); 
        } else {
          // add each edge only once in undirected graphs
          if (NI.GetId() < NI.GetOutNId(e)) {
            EdgeBtwH.AddDat(TIntPr(NI.GetId(), NI.GetOutNId(e)), 0); 
          }
        }
      }
      // add incoming edges in directed graphs that were not added yet
      if (Graph->HasFlag(gfDirected) && !IsDir) {
        for (int e = 0; e < NI.GetInDeg(); e++) {
          if (NI.GetId() < NI.GetInNId(e)  &&
              !Graph->IsEdge(NI.GetId(), NI.GetInNId(e))) {
            EdgeBtwH.AddDat(TIntPr(NI.GetId(), NI.GetInNId(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 typename PGraph::TObj::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 typename PGraph::TObj::TNodeI NI2 = Graph->GetNI(v);
      S.Push(v);
      const int VDat = d.GetDat(v);
      // iterate over all outgoing edges
      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);
        }
      }
      // if ignoring direction in directed networks, iterate over incoming edges
      if (Graph->HasFlag(gfDirected) && !IsDir) {
        for (int e = 0; e < NI2.GetInDeg(); e++) {
          const int w = NI2.GetInNId(e);
          // skip neighbors that are also outgoing
          if (Graph->IsEdge(NI2.GetId(), w)) {
            continue;
          }
          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) {
          if (Graph->HasFlag(gfDirected) && IsDir) {
            EdgeBtwH.AddDat(TIntPr(NId, w)) += c;
          } else {
            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; }
    }
  }
}

template<class PGraph >

double TSnap::GetBfsEffDiam	(	const PGraph &	Graph,
		const int &	NTestNodes,
		const bool &	IsDir = false
	)

Returns the (approximation of the) Effective Diameter (90-th percentile of the distribution of shortest path lengths) of a graph (by performing BFS from NTestNodes random starting nodes).

Parameters

IsDir

false: ignore edge directions and consider edges/paths as undirected (in case they are directed).

Definition at line 424 of file bfsdfs.h.

                                                                                    {
  int FullDiam;
  double EffDiam;
  GetBfsEffDiam(Graph, NTestNodes, IsDir, EffDiam, FullDiam);
  return EffDiam;
}

template<class PGraph >

double TSnap::GetBfsEffDiam	(	const PGraph &	Graph,
		const int &	NTestNodes,
		const bool &	IsDir,
		double &	EffDiamX,
		int &	FullDiamX
	)

Returns the (approximation of the) Effective Diameter and the Diameter of a graph (by performing BFS from NTestNodes random starting nodes).

Parameters

IsDir

false: ignore edge directions and consider edges/paths as undirected (in case they are directed).

Definition at line 432 of file bfsdfs.h.

                                                                                                                    {
  double AvgDiam;
  EffDiam = -1;  FullDiam = -1;
  return GetBfsEffDiam(Graph, NTestNodes, IsDir, EffDiam, FullDiam, AvgDiam);
}

template<class PGraph >

double TSnap::GetBfsEffDiam	(	const PGraph &	Graph,
		const int &	NTestNodes,
		const bool &	IsDir,
		double &	EffDiamX,
		int &	FullDiamX,
		double &	AvgSPLX
	)

Returns the (approximation of the) Effective Diameter, the Diameter and the Average Shortest Path length in a graph (by performing BFS from NTestNodes random starting nodes).

Parameters

IsDir

false: ignore edge directions and consider edges/paths as undirected (in case they are directed).

Definition at line 439 of file bfsdfs.h.

                                                                                                                                    {
  EffDiam = -1;  FullDiam = -1;  AvgSPL = -1;
  TIntFltH DistToCntH;
  TBreathFS<PGraph> BFS(Graph);
  // shotest paths
  TIntV NodeIdV;
  Graph->GetNIdV(NodeIdV);  NodeIdV.Shuffle(TInt::Rnd);
  for (int tries = 0; tries < TMath::Mn(NTestNodes, Graph->GetNodes()); tries++) {
    const int NId = NodeIdV[tries];
    BFS.DoBfs(NId, true, ! IsDir, -1, TInt::Mx);
    for (int i = 0; i < BFS.NIdDistH.Len(); i++) {
      DistToCntH.AddDat(BFS.NIdDistH[i]) += 1; }
  }
  TIntFltKdV DistNbrsPdfV;
  double SumPathL=0, PathCnt=0;
  for (int i = 0; i < DistToCntH.Len(); i++) {
    DistNbrsPdfV.Add(TIntFltKd(DistToCntH.GetKey(i), DistToCntH[i]));
    SumPathL += DistToCntH.GetKey(i) * DistToCntH[i];
    PathCnt += DistToCntH[i];
  }
  DistNbrsPdfV.Sort();
  EffDiam = TSnap::TSnapDetail::CalcEffDiamPdf(DistNbrsPdfV, 0.9); // effective diameter (90-th percentile)
  FullDiam = DistNbrsPdfV.Last().Key;                // approximate full diameter (max shortest path length over the sampled nodes)
  AvgSPL = SumPathL/PathCnt;                        // average shortest path length
  return EffDiam;
}

template<class PGraph >

double TSnap::GetBfsEffDiam	(	const PGraph &	Graph,
		const int &	NTestNodes,
		const TIntV &	SubGraphNIdV,
		const bool &	IsDir,
		double &	EffDiamX,
		int &	FullDiamX
	)

Use the whole graph (all edges) to measure the shortest path lengths but only report the path lengths between nodes in the SubGraphNIdV.

Parameters

IsDir

false: ignore edge directions and consider edges/paths as undirected (in case they are directed).

Definition at line 472 of file bfsdfs.h.

                                                                                                                                               {
  EffDiam = -1;
  FullDiam = -1;

  TIntFltH DistToCntH;
  TBreathFS<PGraph> BFS(Graph);
  // shotest paths
  TIntV NodeIdV(SubGraphNIdV);  NodeIdV.Shuffle(TInt::Rnd);
  TInt Dist;
  for (int tries = 0; tries < TMath::Mn(NTestNodes, SubGraphNIdV.Len()); tries++) {
    const int NId = NodeIdV[tries];
    BFS.DoBfs(NId, true, ! IsDir, -1, TInt::Mx);
    for (int i = 0; i < SubGraphNIdV.Len(); i++) {
      if (BFS.NIdDistH.IsKeyGetDat(SubGraphNIdV[i], Dist)) {
        DistToCntH.AddDat(Dist) += 1;
      }
    }
  }
  TIntFltKdV DistNbrsPdfV;
  for (int i = 0; i < DistToCntH.Len(); i++) {
    DistNbrsPdfV.Add(TIntFltKd(DistToCntH.GetKey(i), DistToCntH[i]));
  }
  DistNbrsPdfV.Sort();
  EffDiam = TSnap::TSnapDetail::CalcEffDiamPdf(DistNbrsPdfV, 0.9);  // effective diameter (90-th percentile)
  FullDiam = DistNbrsPdfV.Last().Key;                 // approximate full diameter (max shortest path length over the sampled nodes)
  return EffDiam;                                     // average shortest path length
}

template<class PGraph >

double TSnap::GetBfsEffDiamAll	(	const PGraph &	Graph,
		const int &	NTestNodes,
		const bool &	IsDir,
		double &	EffDiamX,
		int &	FullDiamX,
		double &	AvgSPLX
	)

Returns the (approximation of the) Effective Diameter, the Diameter and the Average Shortest Path length in a graph (by performing BFS from NTestNodes random starting nodes).

This function is a duplicate. It is required by Snap.py.

Parameters

IsDir

false: ignore edge directions and consider edges/paths as undirected (in case they are directed).

Definition at line 467 of file bfsdfs.h.

                                                                                                                                       {
  return GetBfsEffDiam(Graph, NTestNodes, IsDir, EffDiam, FullDiam, AvgSPL);
}

template<class PGraph >

int TSnap::GetBfsFullDiam	(	const PGraph &	Graph,
		const int &	NTestNodes,
		const bool &	IsDir = false
	)

Returns the (approximation of the) Diameter (maximum shortest path length) of a graph (by performing BFS from NTestNodes random starting nodes).

Parameters

IsDir

false: ignore edge directions and consider edges/paths as undirected (in case they are directed).

Definition at line 416 of file bfsdfs.h.

                                                                                  {
  int FullDiam;
  double EffDiam;
  GetBfsEffDiam(Graph, NTestNodes, IsDir, EffDiam, FullDiam);
  return FullDiam;
}

template<class PGraph >

PNGraph TSnap::GetBfsTree	(	const PGraph &	Graph,
		const int &	StartNId,
		const bool &	FollowOut,
		const bool &	FollowIn
	)

Returns a directed Breadth-First-Search tree rooted at StartNId.

Returns a directed graph where a parent points to its child node. Tree is created by following in-links (parameter FollowIn = true) and/or out-links (parameter FollowOut = true).

Definition at line 332 of file bfsdfs.h.

                                                                                                          {
  TBreathFS<PGraph> BFS(Graph);
  BFS.DoBfs(StartNId, FollowOut, FollowIn, -1, TInt::Mx);
  PNGraph Tree = TNGraph::New();
  BFS.NIdDistH.SortByDat();
  for (int i = 0; i < BFS.NIdDistH.Len(); i++) {
    const int NId = BFS.NIdDistH.GetKey(i);
    const int Dist = BFS.NIdDistH[i];
    typename PGraph::TObj::TNodeI NI = Graph->GetNI(NId);
    if (!Tree->IsNode(NId)) {
      Tree->AddNode(NId);
    }
    if (FollowOut) {
      for (int e = 0; e < NI.GetInDeg(); e++) {
        const int Prev = NI.GetInNId(e);
        if (Tree->IsNode(Prev) && BFS.NIdDistH.GetDat(Prev)==Dist-1) {
          Tree->AddEdge(Prev, NId); }
      }
    }
    if (FollowIn) {
      for (int e = 0; e < NI.GetOutDeg(); e++) {
        const int Prev = NI.GetOutNId(e);
        if (Tree->IsNode(Prev) && BFS.NIdDistH.GetDat(Prev)==Dist-1) {
          Tree->AddEdge(Prev, NId); }
      }
    }
  }
  return Tree;
}

void TSnap::GetBiCon	(	const PUNGraph &	Graph,
		TCnComV &	BiCnComV
	)

Returns all bi-connected components of a Graph.

Parameters

BiCnComV

is a vector of bi-connected components. Each component is defined by the IDs of its member nodes.

Definition at line 42 of file cncom.cpp.

                                                        {
  TBiConVisitor Visitor(Graph->GetNodes());
  TCnCom::GetDfsVisitor(Graph, Visitor);
  BiCnComV = Visitor.CnComV;
}

void TSnap::GetBiConSzCnt	(	const PUNGraph &	Graph,
		TIntPrV &	SzCntV
	)

Returns a distribution of bi-connected component sizes.

Parameters

SzCntV

returns a set of pairs (number of nodes in the bi-component, number of such components)

Definition at line 31 of file cncom.cpp.

                                                           {
  TCnComV BiCnComV;
  GetBiCon(Graph, BiCnComV);
  TIntH SzCntH;
  for (int c =0; c < BiCnComV.Len(); c++) {
    SzCntH.AddDat(BiCnComV[c].Len()) += 1;
  }
  SzCntH.GetKeyDatPrV(SzCntV);
  SzCntV.Sort();
}

template<class PGraph >

double TSnap::GetClosenessCentr	(	const PGraph &	Graph,
		const int &	NId,
		const bool &	Normalized = true,
		const bool &	IsDir = false
	)

Returns Closeness centrality of a given node NId. Closeness centrality of a node is defined as 1/FarnessCentrality.

Definition at line 161 of file centr.h.

                                                                                                         {
  const double Farness = GetFarnessCentr<PGraph> (Graph, NId, Normalized, IsDir);
  if (Farness != 0.0) { return 1.0/Farness; }
  else { return 0.0; }
  return 0.0;
}

template<class PGraph >

double TSnap::GetClosenessCentrMP	(	const PGraph &	Graph,
		const int &	NId,
		const bool &	Normalized = true,
		const bool &	IsDir = false
	)

Definition at line 169 of file centr.h.

                                                                                                           {
  const double Farness = GetFarnessCentrMP<PGraph> (Graph, NId, Normalized, IsDir);
  if (Farness != 0.0) { return 1.0/Farness; }
  else { return 0.0; }
  return 0.0;
}

template<class PGraph >

double TSnap::GetClustCf	(	const PGraph &	Graph,
		int	SampleNodes = -1
	)

Computes the average clustering coefficient as defined in Watts and Strogatz, Collective dynamics of 'small-world' networks.

Considers the graph as undirected.

Definition at line 137 of file triad.h.

                                                                                {
  TIntTrV NIdCOTriadV;
  GetTriads(Graph, NIdCOTriadV, SampleNodes);
  if (NIdCOTriadV.Empty()) { return 0.0; }
  double SumCcf = 0.0;
  for (int i = 0; i < NIdCOTriadV.Len(); i++) {
    const double OpenCnt = NIdCOTriadV[i].Val2()+NIdCOTriadV[i].Val3();
    if (OpenCnt > 0) {
      SumCcf += NIdCOTriadV[i].Val2() / OpenCnt; }
  }
  IAssert(SumCcf>=0);
  return SumCcf / double(NIdCOTriadV.Len());
}

template<class PGraph >

double TSnap::GetClustCf	(	const PGraph &	Graph,
		TFltPrV &	DegToCCfV,
		int	SampleNodes = -1
	)

Computes the distribution of average clustering coefficient.

Considers the graph as undirected.

Parameters

DegToCCfV	Vector of pairs (degree, avg. clustering coefficient of nodes of that degree).
SampleNodes	If !=-1 then compute clustering coefficient only for a random sample of SampleNodes nodes. Useful for approximate but quick computations.

Definition at line 151 of file triad.h.

                                                                                                    {
  TIntTrV NIdCOTriadV;
  GetTriads(Graph, NIdCOTriadV, SampleNodes);
  if (NIdCOTriadV.Empty()) {
    DegToCCfV.Clr(false);
    return 0.0;
  }
  THash<TInt, TFltPr> DegSumCnt;
  double SumCcf = 0.0;
  for (int i = 0; i < NIdCOTriadV.Len(); i++) {
    const int D = NIdCOTriadV[i].Val2()+NIdCOTriadV[i].Val3();
    const double Ccf = D!=0 ? NIdCOTriadV[i].Val2() / double(D) : 0.0;
    TFltPr& SumCnt = DegSumCnt.AddDat(Graph->GetNI(NIdCOTriadV[i].Val1).GetDeg());
    SumCnt.Val1 += Ccf;
    SumCnt.Val2 += 1;
    SumCcf += Ccf;
  }
  // get average clustering coefficient for each degree
  DegToCCfV.Gen(DegSumCnt.Len(), 0);
  for (int d = 0; d  < DegSumCnt.Len(); d++) {
    DegToCCfV.Add(TFltPr(DegSumCnt.GetKey(d).Val, double(DegSumCnt[d].Val1()/DegSumCnt[d].Val2())));
  }
  DegToCCfV.Sort();
  return SumCcf / double(NIdCOTriadV.Len());
}

template<class PGraph >

double TSnap::GetClustCf	(	const PGraph &	Graph,
		TFltPrV &	DegToCCfV,
		int64 &	ClosedTriads,
		int64 &	OpenTriads,
		int	SampleNodes = -1
	)

Computes the distribution of average clustering coefficient as well as the number of open and closed triads in the graph.

Considers the graph as undirected.

Parameters

DegToCCfV	Vector of pairs (degree, avg. clustering coefficient of nodes of that degree).
ClosedTriads	On return contains the number of closed triads.
OpenTriads	On return contains the number of open triads.
SampleNodes	If !=-1 then compute clustering coefficient only for a random sample of SampleNodes nodes. Useful for approximate but quick computations.

Definition at line 178 of file triad.h.

                                                                                                                    {
  TIntTrV NIdCOTriadV;
  GetTriads(Graph, NIdCOTriadV, SampleNodes);
  if (NIdCOTriadV.Empty()) {
    DegToCCfV.Clr(false);
    ClosedTriads = 0;
    OpenTriads = 0;
    return 0.0;
  }
  THash<TInt, TFltPr> DegSumCnt;
  double SumCcf = 0.0;
  int64 closedTriads = 0;
  int64 openTriads = 0;
  for (int i = 0; i < NIdCOTriadV.Len(); i++) {
    const int D = NIdCOTriadV[i].Val2()+NIdCOTriadV[i].Val3();
    const double Ccf = D!=0 ? NIdCOTriadV[i].Val2() / double(D) : 0.0;
    closedTriads += NIdCOTriadV[i].Val2;
    openTriads += NIdCOTriadV[i].Val3;
    TFltPr& SumCnt = DegSumCnt.AddDat(Graph->GetNI(NIdCOTriadV[i].Val1).GetDeg());
    SumCnt.Val1 += Ccf;
    SumCnt.Val2 += 1;
    SumCcf += Ccf;
  }
  // get average clustering coefficient for each degree
  DegToCCfV.Gen(DegSumCnt.Len(), 0);
  for (int d = 0; d  < DegSumCnt.Len(); d++) {
    DegToCCfV.Add(TFltPr(DegSumCnt.GetKey(d).Val, DegSumCnt[d].Val1()/DegSumCnt[d].Val2()));
  }
  //if(closedTriads/3 > (uint64) TInt::Mx) { WarnNotify(TStr::Fmt("[%s line %d] %g closed triads.\n", __FILE__, __LINE__, float(closedTriads/3)).CStr());  }
  //if(openTriads > (uint64) TInt::Mx) { WarnNotify(TStr::Fmt("[%s line %d] %g open triads.\n", __FILE__, __LINE__, float(openTriads/3)).CStr());  }
  ClosedTriads = closedTriads/int64(3); // each triad is counted 3 times
  OpenTriads = openTriads;
  DegToCCfV.Sort();
  return SumCcf / double(NIdCOTriadV.Len());
}

template<class PGraph >

double TSnap::GetClustCfAll	(	const PGraph &	Graph,
		TFltPrV &	DegToCCfV,
		int64 &	ClosedTriadsX,
		int64 &	OpenTriadsX,
		int	SampleNodes = -1
	)

Computes the distribution of average clustering coefficient as well as the number of open and closed triads in the graph.

Considers the graph as undirected. This function is a duplicate. It is required by Snap.py.

Parameters

DegToCCfV	Vector of pairs (degree, avg. clustering coefficient of nodes of that degree).
ClosedTriads	On return contains the number of closed triads.
OpenTriads	On return contains the number of open triads.
SampleNodes	If !=-1 then compute clustering coefficient only for a random sample of SampleNodes nodes. Useful for approximate but quick computations.

Definition at line 215 of file triad.h.

                                                                                                                       {
  return GetClustCf(Graph, DegToCCfV, ClosedTriads, OpenTriads, SampleNodes);
}

template<class PGraph >

int TSnap::GetCmnNbrs	(	const PGraph &	Graph,
		const int &	NId1,
		const int &	NId2
	)

Returns a number of shared neighbors between a pair of nodes NId1 and NId2.

Definition at line 708 of file triad.h.

                                                                      {
  TIntV NbrV;
  return GetCmnNbrs(Graph, NId1, NId2, NbrV);
}

template<class PGraph >

int TSnap::GetCmnNbrs	(	const PGraph &	Graph,
		const int &	NId1,
		const int &	NId2,
		TIntV &	NbrV
	)

Returns the shared neighbors between a pair of nodes NId1 and NId2.

Definition at line 715 of file triad.h.

                                                                                   {
  if (! Graph->IsNode(NId1) || ! Graph->IsNode(NId2)) { NbrV.Clr(false); return 0; }
  typename PGraph::TObj::TNodeI NI1 = Graph->GetNI(NId1);
  typename PGraph::TObj::TNodeI NI2 = Graph->GetNI(NId2);
  NbrV.Clr(false);
  NbrV.Reserve(TMath::Mn(NI1.GetDeg(), NI2.GetDeg()));
  TIntSet NSet1(NI1.GetDeg()), NSet2(NI2.GetDeg());
  for (int i = 0; i < NI1.GetDeg(); i++) {
    const int nid = NI1.GetNbrNId(i);
    if (nid!=NId1 && nid!=NId2) {
      NSet1.AddKey(nid); }
  }
  for (int i = 0; i < NI2.GetDeg(); i++) {
    const int nid = NI2.GetNbrNId(i);
    if (NSet1.IsKey(nid)) {
      NSet2.AddKey(nid);
    }
  }
  NSet2.GetKeyV(NbrV);
  return NbrV.Len();
}

template<>

int TSnap::GetCmnNbrs< PUNGraph > ( const PUNGraph &  Graph, const int &  NId1, const int &  NId2, TIntV &  NbrV  )

inline

Definition at line 738 of file triad.h.

                                                                                                      {
  if (! Graph->IsNode(NId1) || ! Graph->IsNode(NId2)) { NbrV.Clr(false); return 0; }
  const TUNGraph::TNodeI NI1 = Graph->GetNI(NId1);
  const TUNGraph::TNodeI NI2 = Graph->GetNI(NId2);
  int i=0, j=0;
  NbrV.Clr(false);
  NbrV.Reserve(TMath::Mn(NI1.GetDeg(), NI2.GetDeg()));
  while (i < NI1.GetDeg() && j < NI2.GetDeg()) {
    const int nid = NI1.GetNbrNId(i);
    while (j < NI2.GetDeg() && NI2.GetNbrNId(j) < nid) { j++; }
    if (j < NI2.GetDeg() && nid==NI2.GetNbrNId(j) && nid!=NId1 && nid!=NId2) {
      IAssert(NbrV.Empty() || NbrV.Last() < nid);
      NbrV.Add(nid);
      j++;
    }
    i++;
  }
  return NbrV.Len();
}

int TSnap::GetCommon	(	TIntV &	A,
		TIntV &	B
	)

Returns the number of common elements in two sorted TInt vectors.

Definition at line 59 of file triad.cpp.

                                  {
  int i, j;
  int ret = 0;
  int alen, blen;
  int d;
  TInt ai;

  alen = A.Len();
  blen = B.Len();
  i = 0;
  j = 0;
  if (i >= alen  ||  j >= blen) {
    return ret;
  }

  while (1) {
    d = A[i] - B[j];
    if (d < 0) {
      i++;
      if (i >= alen) {
        break;
      }
    } else if (d > 0) {
      j++;
      if (j >= blen) {
        break;
      }
    } else {
      ret++;
      i++;
      if (i >= alen) {
        break;
      }
      j++;
      if (j >= blen) {
        break;
      }
    }
  }
  return ret;
}

template<class PGraph >

void TSnap::GetDegCnt	(	const PGraph &	Graph,
		TIntPrV &	DegToCntV
	)

Returns a degree histogram: a set of pairs (degree, number of nodes of such degree)

Definition at line 223 of file alg.h.

                                                        {
  TIntH DegToCntH;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    DegToCntH.AddDat(NI.GetDeg())++; }
  DegToCntV.Gen(DegToCntH.Len(), 0);
  for (int i = 0; i < DegToCntH.Len(); i++) {
    DegToCntV.Add(TIntPr(DegToCntH.GetKey(i), DegToCntH[i])); }
  DegToCntV.Sort();
}

template<class PGraph >

void TSnap::GetDegCnt	(	const PGraph &	Graph,
		TFltPrV &	DegToCntV
	)

Returns a degree histogram: a set of pairs (degree, number of nodes of such degree)

Definition at line 234 of file alg.h.

                                                        {
  TIntH DegToCntH;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    DegToCntH.AddDat(NI.GetDeg())++; }
  DegToCntV.Gen(DegToCntH.Len(), 0);
  for (int i = 0; i < DegToCntH.Len(); i++) {
    DegToCntV.Add(TFltPr(DegToCntH.GetKey(i).Val, DegToCntH[i].Val)); }
  DegToCntV.Sort();
}

double TSnap::GetDegreeCentr	(	const PUNGraph &	Graph,
		const int &	NId
	)

Returns Degree centrality of a given node NId. Degree centrality if a node is defined as its degree/(N-1), where N is the number of nodes in the network.

Definition at line 5 of file centr.cpp.

                                                             {
  if (Graph->GetNodes() > 1) {
    return double(Graph->GetNI(NId).GetDeg())/double(Graph->GetNodes()-1); }
  else { return 0.0; }
}

template<class PGraph >

void TSnap::GetDegSeqV	(	const PGraph &	Graph,
		TIntV &	DegV
	)

Returns a degree sequence vector.

Definition at line 245 of file alg.h.

                                                  {
  DegV.Gen(Graph->GetNodes(), 0);
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    DegV.Add(NI.GetDeg());
  }
}

template<class PGraph >

void TSnap::GetDegSeqV	(	const PGraph &	Graph,
		TIntV &	InDegV,
		TIntV &	OutDegV
	)

Returns an in- and out-degree sequence vectors.

Definition at line 253 of file alg.h.

                                                                    {
  InDegV.Gen(Graph->GetNodes(), 0);
  OutDegV.Gen(Graph->GetNodes(), 0);
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    InDegV.Add(NI.GetInDeg());
    OutDegV.Add(NI.GetOutDeg());
  }
}

template<class PGraph , class TEdgeDat >

PGraph TSnap::GetEDatSubGraph	(	const PGraph &	Graph,
		const TEdgeDat &	EDat,
		const int &	Cmp
	)

Returns a subgraph of graph Graph with edges where edge data matches the parameters.

EDat provides the value for edge data matching. Cmp determines the comparison function. Edges whose edge data matches EDat are included in the resulting subgraph as well as all the nodes which connect to at least one edge in the subgraph. Node IDs are preserved. Nodes in the resulting subgraph have the same node IDs as nodes in Graph.

Values of Cmp can be -1, 0, or +1. If Cmp is -1, edges with edge data less than EDat are included in the resulting subgraph. If Cmp equals 0, the values of edge data and EDat have to match. If Cmp is +1, edge data has to be greater than EDat.

Definition at line 286 of file subgraph.h.

                                                                                  {
  CAssert(HasGraphFlag(typename PGraph::TObj, gfEdgeDat));
  PGraph NewGraphPt = PGraph::TObj::New();
  typename PGraph::TObj& NewGraph = *NewGraphPt;
  for (typename PGraph::TObj::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
    if ((Cmp==1 && EI()>EDat) || (Cmp==-1 && EI()<EDat) || (Cmp==0 && EI()==EDat)) {
      if (! NewGraph.IsNode(EI.GetSrcNId())) {
        NewGraph.AddNode(Graph->GetNI(EI.GetSrcNId()));
      }
      if (! NewGraph.IsNode(EI.GetDstNId())) {
        NewGraph.AddNode(Graph->GetNI(EI.GetDstNId()));
      }
      NewGraph.AddEdge(EI); 
    }
  }
  return NewGraphPt;
}

template<class PGraph , class TEdgeDat >

PGraph TSnap::GetEDatSubGraph	(	const PGraph &	Graph,
		const TIntV &	NIdV,
		const TEdgeDat &	EDat,
		const int &	Cmp
	)

Returns a subgraph of graph Graph with NIdV nodes and edges where edge data matches the parameters.

The resulting subgraph contains all the nodes from Graph, which have node IDs in the NIdV vector and edges with both nodes in NIdV and whose edge data matches the parameters. Node IDs are preserved. Nodes in the resulting subgraph have the same node IDs as nodes in Graph.

EDat provides the value for edge data matching. Cmp determines the comparison function. Values of Cmp can be -1, 0, or +1. If Cmp is -1, edges with edge data less than EDat are included in the resulting subgraph. If Cmp equals 0, the values of edge data and EDat have to match. If Cmp is +1, edge data has to be greater than EDat.

Definition at line 306 of file subgraph.h.

                                                                                                     {
  CAssert(HasGraphFlag(typename PGraph::TObj, gfEdgeDat));
  PGraph NewGraphPt = PGraph::TObj::New();
  typename PGraph::TObj& NewGraph = *NewGraphPt;
  NewGraph.Reserve(NIdV.Len(), -1);
  for (int n = 0; n < NIdV.Len(); n++) {
    NewGraph.AddNode(Graph->GetNI(NIdV[n])); 
  }
  for (typename PGraph::TObj::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
    if (NewGraph.IsNode(EI.GetSrcNId()) && NewGraph.IsNode(EI.GetDstNId()) &&
     ((Cmp==1 && EI()>EDat)|| (Cmp==-1 && EI()<EDat) || (Cmp==0 && EI()==EDat))) {
      NewGraph.AddEdge(EI); }
  }
  NewGraph.Defrag();
  return NewGraphPt;
}

void TSnap::GetEdgeBridges	(	const PUNGraph &	Graph,
		TIntPrV &	EdgeV
	)

Returns bridge edges of a Graph.

Edge is a bridge if, when removed, increases the number of connected components. See http://en.wikipedia.org/wiki/Bridge_(graph_theory)

Definition at line 55 of file cncom.cpp.

                                                           {
  TCnComV BiCnComV;
  GetBiCon(Graph, BiCnComV);
  TIntPrSet EdgeSet;
  for (int c = 0; c < BiCnComV.Len(); c++) {
    const TIntV& NIdV = BiCnComV[c].NIdV; 
    if (NIdV.Len() == 2) {
      EdgeSet.AddKey(TIntPr(TMath::Mn(NIdV[0], NIdV[1]), TMath::Mx(NIdV[0], NIdV[1]))); 
    }
  }
  EdgeSet.GetKeyV(EdgeV);
}

template<typename PGraph >

void TSnap::GetEdgesInOut	(	const PGraph &	Graph,
		const TIntV &	NIdV,
		int &	EdgesInX,
		int &	EdgesOutX
	)

Returns the number of edges between the nodes NIdV and the edges pointing outside the set NIdV.

Parameters

EdgesInX	Number of edges between the nodes NIdV.
EdgesOutX	Number of edges between the nodes in NIdV and the rest of the graph.

Definition at line 76 of file cmty.h.

                                                                                        {
  EdgesIn = 0;
  EdgesOut = 0;
  TIntSet NIdSet(NIdV.Len());
  for (int e = 0; e < NIdV.Len(); e++) {
    NIdSet.AddKey(NIdV[e]);
  }
  for (int e = 0; e < NIdV.Len(); e++) {
    typename PGraph::TObj::TNodeI NI = Graph->GetNI(NIdV[e]);
    for (int i = 0; i < NI.GetOutDeg(); i++) {
      if (NIdSet.IsKey(NI.GetOutNId(i))) { EdgesIn += 1; }
      else { EdgesOut += 1; }
    }
  }
  EdgesIn /= 2;
}

PUNGraph TSnap::GetEgonet	(	const PUNGraph &	Graph,
		const int	CtrNId,
		int &	ArndEdges
	)

Returns the egonet of node CtrNId as center in undirected graph Graph. And returns number of edges around the egonet.

Definition at line 82 of file subgraph.cpp.

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

PNGraph TSnap::GetEgonet	(	const PNGraph &	Graph,
		const int	CtrNId,
		int &	InEdges,
		int &	OutEdges
	)

Returns the egonet of node CtrNId as center in directed graph Graph. And returns number of edges go in and out the egonet.

Definition at line 108 of file subgraph.cpp.

                                                                                       {
  PNGraph NewGraphPt = TNGraph::New();
  TNGraph& NewGraph = *NewGraphPt;
  NewGraph.AddNode(CtrNId);
  const TNGraph::TNodeI& CtrNode = Graph->GetNI(CtrNId);
  for (int i = 0; i < CtrNode.GetDeg(); ++i) {
    if (!NewGraph.IsNode(CtrNode.GetNbrNId(i))) {
      NewGraph.AddNode(CtrNode.GetNbrNId(i));
    }
  }
  InEdges = 0;
  OutEdges = 0;
  for (int i = 0; i < CtrNode.GetDeg(); ++i) {
    int NbrNId = CtrNode.GetNbrNId(i);
    const TNGraph::TNodeI& NbrNode = Graph->GetNI(NbrNId);
    for (int j = 0; j < NbrNode.GetInDeg(); ++j) {
      int NbrNbrNId = NbrNode.GetInNId(j);
      if (NewGraph.IsNode(NbrNbrNId)) {
        NewGraph.AddEdge(NbrNbrNId, NbrNId);
      } else {
        InEdges++;
      }
    }
    for (int j = 0; j < NbrNode.GetOutDeg(); ++j) {
      int NbrNbrNId = NbrNode.GetOutNId(j);
      if (NewGraph.IsNode(NbrNbrNId)) {
        NewGraph.AddEdge(NbrNId, NbrNbrNId);
      } else {
        OutEdges++;
      }
    }
  }
  return NewGraphPt;
}

PNEANet TSnap::GetEgonetAttr	(	const PNEANet &	Graph,
		const int	CtrNId,
		const int	Radius
	)

Returns the complete egonet of at given radius and copies node and edge attributes.

Definition at line 254 of file subgraph.cpp.

                                                                                {
  PNEANet NewGraphPt = PNEANet::New();
  TNEANet &NewGraph = *NewGraphPt;
  TSnapQueue<int> Queue1;
  TSnapQueue<int> Queue2;
  TSnapQueue<int> tempSwapQueue;
  AddNodeWithAttributes(Graph, NewGraphPt, CtrNId);
  Queue1.Clr(false);
  Queue1.Push(CtrNId);
  for (int r = 0; r < Radius; ++r) {
    while (!Queue1.Empty()) {
      const int NId = Queue1.Top();
      Queue1.Pop();
      const TNEANet::TNodeI &Node = Graph->GetNI(NId);
      for (int i = 0; i < Node.GetInDeg(); ++i) {
        const int InNId = Node.GetInNId(i);
        if (!NewGraph.IsNode(InNId)) {
          AddNodeWithAttributes(Graph, NewGraphPt, InNId);
          Queue2.Push(InNId);
        }
        const int InEId = Node.GetInEId(i);
        if (!NewGraph.IsEdge(InEId)) {
          AddEdgeWithAttributes(Graph, NewGraphPt, InEId);
        }
      }
      for (int i = 0; i < Node.GetOutDeg(); ++i) {
        const int OutNId = Node.GetOutNId(i);
        if (!NewGraph.IsNode(OutNId)) {
          AddNodeWithAttributes(Graph, NewGraphPt, OutNId);
          Queue2.Push(OutNId);
        }
        const int OutEId = Node.GetOutEId(i);
        if (!NewGraph.IsEdge(OutEId)) {
          AddEdgeWithAttributes(Graph, NewGraphPt, OutEId);
        }
      }
      for (int i = 0; i < Node.GetInDeg(); ++i) {
        int InNId = Node.GetInNId(i);
        const TNEANet::TNodeI &InNode = Graph->GetNI(InNId);
        for (int j = 0; j < InNode.GetInDeg(); ++j) {
          int NbrInNId = InNode.GetInNId(j);
          if (NewGraph.IsNode(NbrInNId)) {
            const int NbrInEId = InNode.GetInEId(j);
            if (!NewGraph.IsEdge(NbrInEId)) {
              AddEdgeWithAttributes(Graph, NewGraphPt, NbrInEId);
            }
          }
        }
        for (int j = 0; j < InNode.GetOutDeg(); ++j) {
          int NbrOutNId = InNode.GetOutNId(j);
          if (NewGraph.IsNode(NbrOutNId)) {
            const int NbrOutEId = InNode.GetOutEId(j);
            if (!NewGraph.IsEdge(NbrOutEId)) {
              AddEdgeWithAttributes(Graph, NewGraphPt, NbrOutEId);
            }
          }
        }
      }
      for (int i = 0; i < Node.GetOutDeg(); ++i) {
        int OutNId = Node.GetOutNId(i);
        const TNEANet::TNodeI &OutNode = Graph->GetNI(OutNId);
        for (int j = 0; j < OutNode.GetInDeg(); ++j) {
          int NbrInNId = OutNode.GetInNId(j);
          if (NewGraph.IsNode(NbrInNId)) {
            const int NbrInEId = OutNode.GetInEId(j);
            if (!NewGraph.IsEdge(NbrInEId)) {
              AddEdgeWithAttributes(Graph, NewGraphPt, NbrInEId);
            }
          }
        }
        for (int j = 0; j < OutNode.GetOutDeg(); ++j) {
          int NbrOutNId = OutNode.GetOutNId(j);
          if (NewGraph.IsNode(NbrOutNId)) {
            const int NbrOutEId = OutNode.GetOutEId(j);
            if (!NewGraph.IsEdge(NbrOutEId)) {
              AddEdgeWithAttributes(Graph, NewGraphPt, NbrOutEId);
            }
          }
        }
      }
    }
    tempSwapQueue = Queue1;
    Queue1 = Queue2;
    Queue2 = tempSwapQueue;
  }
  return NewGraphPt;
}

template<class PGraph >

PGraph TSnap::GetEgonetHop	(	const PGraph &	Graph,
		const int	CtrNId,
		const int	Radius
	)

Returns the egonet of node CtrNId as center for a Graph for a given radius.

Definition at line 506 of file subgraph.h.

                                                                             {
  PGraph NewGraphPt = PGraph::TObj::New();
  typename PGraph::TObj& NewGraph = *NewGraphPt;
  TSnapQueue<int> Queue1;
  TSnapQueue<int> Queue2;
  TSnapQueue<int> tempSwapQueue;
  NewGraph.AddNode(CtrNId);
  Queue1.Clr(false);
  Queue1.Push(CtrNId);
  for (int r = 0; r < Radius; ++r) {
    while (!Queue1.Empty()) {
      const int NId = Queue1.Top();
      Queue1.Pop();
      const typename PGraph::TObj::TNodeI &Node = Graph->GetNI(NId);
      for (int i = 0; i < Node.GetInDeg(); ++i) {
        const int InNId = Node.GetInNId(i);
        if (!NewGraph.IsNode(InNId)) {
          NewGraph.AddNode(InNId);
          Queue2.Push(InNId);
        }
        if (!NewGraph.IsEdge(InNId, NId)) {
          NewGraph.AddEdge(InNId, NId);
        }
      }
      for (int i = 0; i < Node.GetOutDeg(); ++i) {
        const int OutNId = Node.GetOutNId(i);
        if (!NewGraph.IsNode(OutNId)) {
          NewGraph.AddNode(OutNId);
          Queue2.Push(OutNId);
        }
        if (!NewGraph.IsEdge(NId, OutNId)) {
          NewGraph.AddEdge(NId, OutNId);
        }
      }
      for (int i = 0; i < Node.GetInDeg(); ++i) {
        int InNId = Node.GetInNId(i);
        const typename PGraph::TObj::TNodeI &InNode = Graph->GetNI(InNId);
        for (int j = 0; j < InNode.GetInDeg(); ++j) {
          int NbrInNId = InNode.GetInNId(j);
          if (NewGraph.IsNode(NbrInNId)) {
            if (!NewGraph.IsEdge(NbrInNId, InNId)) {
              NewGraph.AddEdge(NbrInNId, InNId);
            }
          }
        }
        for (int j = 0; j < InNode.GetOutDeg(); ++j) {
          int NbrOutNId = InNode.GetOutNId(j);
          if (NewGraph.IsNode(NbrOutNId)) {
            if (!NewGraph.IsEdge(InNId, NbrOutNId)) {
              NewGraph.AddEdge(InNId, NbrOutNId);
            }
          }
        }
      }
      for (int i = 0; i < Node.GetOutDeg(); ++i) {
        int OutNId = Node.GetOutNId(i);
        const typename PGraph::TObj::TNodeI &OutNode = Graph->GetNI(OutNId);
        for (int j = 0; j < OutNode.GetInDeg(); ++j) {
          int NbrInNId = OutNode.GetInNId(j);
          if (NewGraph.IsNode(NbrInNId)) {
            if (!NewGraph.IsEdge(NbrInNId, OutNId)) {
              NewGraph.AddEdge(NbrInNId, OutNId);
            }
          }
        }
        for (int j = 0; j < OutNode.GetOutDeg(); ++j) {
          int NbrOutNId = OutNode.GetOutNId(j);
          if (NewGraph.IsNode(NbrOutNId)) {
            if (!NewGraph.IsEdge(OutNId, NbrOutNId)) {
              NewGraph.AddEdge(OutNId, NbrOutNId);
            }
          }
        }
      }
    }
    tempSwapQueue = Queue1;
    Queue1 = Queue2;
    Queue2 = tempSwapQueue;
  }
  return NewGraphPt;
}

void TSnap::GetEigenVectorCentr	(	const PUNGraph &	Graph,
		TIntFltH &	NIdEigenH,
		const double &	Eps = 1e-4,
		const int &	MaxIter = 100
	)

Computes Eigenvector Centrality of all nodes in the network Eigenvector Centrality of a node N is defined recursively as the average of centrality values of N's neighbors in the network.

Definition at line 11 of file centr.cpp.

                                                                                                            {
  const int NNodes = Graph->GetNodes();
  NIdEigenH.Gen(NNodes);
  // initialize vector values
  for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    NIdEigenH.AddDat(NI.GetId(), 1.0/NNodes);
    IAssert(NI.GetId() == NIdEigenH.GetKey(NIdEigenH.Len()-1));
  }
  TFltV TmpV(NNodes);
  for (int iter = 0; iter < MaxIter; iter++) {
    int j = 0;
    // add neighbor values
    for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++, j++) {
      TmpV[j] = 0;
      for (int e = 0; e < NI.GetOutDeg(); e++) {
        TmpV[j] += NIdEigenH.GetDat(NI.GetOutNId(e)); }
    }

    // normalize
    double sum = 0;
    for (int i = 0; i < TmpV.Len(); i++) {
      sum += (TmpV[i]*TmpV[i]);
    }
    sum = sqrt(sum);
    for (int i = 0; i < TmpV.Len(); i++) {
      TmpV[i] /= sum;
    }

    // compute difference
    double diff = 0.0;
    j = 0;
    for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++, j++) {
      diff += fabs(NIdEigenH.GetDat(NI.GetId())-TmpV[j]);
    }

    // set new values
    j = 0;
    for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++, j++) {
      NIdEigenH.AddDat(NI.GetId(), TmpV[j]);
    }

    if (diff < Eps) {
      break;
    }
  }
}

void TSnap::GetEigVals	(	const PUNGraph &	Graph,
		const int &	EigVals,
		TFltV &	EigValV
	)

Computes top EigVals eigenvalues of the adjacency matrix representing a given undirected Graph.

Definition at line 308 of file gsvd.cpp.

                                                                           {
  // Lanczos
  TUNGraphMtx GraphMtx(Graph);
  //const int Nodes = Graph->GetNodes();
  //int CalcVals = int(2*EigVals);
  //if (CalcVals > Nodes) { CalcVals = Nodes; }
  //while (EigValV.Len() < EigVals && CalcVals < 3*EigVals) {
  try {
    if (EigVals > 4) { 
      TSparseSVD::SimpleLanczos(GraphMtx, 2*EigVals, EigValV, false); }
    else { TFltVV EigVecVV; // this is much more precise, but also much slower
      TSparseSVD::Lanczos(GraphMtx, EigVals, 3*EigVals, ssotFull, EigValV, EigVecVV, false); }
  }
  catch(...) {
    printf("\n  ***EXCEPTION:  TRIED %d GOT %d values** \n", 2*EigVals, EigValV.Len()); }
  if (EigValV.Len() < EigVals) {
    printf("  ***TRIED %d GOT %d values** \n", 2*EigVals, EigValV.Len()); }
  //  CalcVals += EigVals;
  //}
  EigValV.Sort(false);
  /*if (EigValV.Len() > EigVals) {
    EigValV.Del(EigVals, EigValV.Len()-1); }
  else {
    while (EigValV.Len() < EigVals) EigValV.Add(1e-6); 
  }
  IAssert(EigValV.Len() == EigVals);*/
}

void TSnap::GetEigVec	(	const PUNGraph &	Graph,
		TFltV &	EigVecV
	)

Computes the leading eigenvector of the adjacency matrix representing a given undirected Graph.

Definition at line 336 of file gsvd.cpp.

                                                      {
  TUNGraphMtx GraphMtx(Graph);
  TFltV EigValV;
  TFltVV EigVecVV;
  TSparseSVD::Lanczos(GraphMtx, 1, 8, ssotFull, EigValV, EigVecVV, false);
  EigVecVV.GetCol(0, EigVecV); // vector components are not sorted!!!
  IsAllValVNeg(EigVecV, true);
}

void TSnap::GetEigVec	(	const PUNGraph &	Graph,
		const int &	EigVecs,
		TFltV &	EigValV,
		TFltVFltV &	EigVecV
	)

Computes top EigVecs eigenvalues and eigenvectors of the adjacency matrix representing a given undirected Graph.

Definition at line 347 of file gsvd.cpp.

                                                                                              {
  const int Nodes = Graph->GetNodes();
  // Lanczos
  TUNGraphMtx GraphMtx(Graph);
  int CalcVals = int(2*EigVecs);
  if (CalcVals > Nodes) { CalcVals = Nodes; }
  TFltVV EigVecVV;
  //while (EigValV.Len() < EigVecs && CalcVals < 10*EigVecs) {
  try {
    TSparseSVD::Lanczos(GraphMtx, EigVecs, 2*EigVecs, ssotFull, EigValV, EigVecVV, false); }
  catch(...) {
    printf("\n  ***EXCEPTION:  TRIED %d GOT %d values** \n", CalcVals, EigValV.Len()); }
  if (EigValV.Len() < EigVecs) {
    printf("  ***TRIED %d GOT %d values** \n", CalcVals, EigValV.Len()); }
  //  CalcVals += EigVecs;
  //}
  TFltIntPrV EigValIdV;
  for (int i = 0; i < EigValV.Len(); i++) {
    EigValIdV.Add(TFltIntPr(EigValV[i], i)); 
  }
  EigValIdV.Sort(false);
  EigValV.Sort(false);
  for (int v = 0; v < EigValIdV.Len(); v++) { // vector components are not sorted!!!
    EigVecV.Add();
    EigVecVV.GetCol(EigValIdV[v].Val2, EigVecV.Last());
  }
  IsAllValVNeg(EigVecV[0], true);
}

template<class PGraph >

PGraph TSnap::GetESubGraph	(	const PGraph &	Graph,
		const TIntV &	EIdV
	)

Returns a subgraph of graph Graph with EIdV edges.

The resulting subgraph contains all the edges from Graph, which have edge IDs in the EIdV vector and all the nodes which connect to at least one edge in EIdV. Node and edge IDs are preserved. Nodes and edges in the resulting subgraph have the same IDs as in Graph.

Use this function for multi-graphs, where the edges have edge IDs.

Definition at line 243 of file subgraph.h.

                                                            {
  CAssert(HasGraphFlag(typename PGraph::TObj, gfMultiGraph));
  PGraph NewGraphPt = PGraph::TObj::New();
  typename PGraph::TObj& NewGraph = *NewGraphPt;
  NewGraph.Reserve(-1, EIdV.Len());
  for (int edge = 0; edge < EIdV.Len(); edge++) {
    const int EId = EIdV[edge];
    IAssert(Graph->IsEdge(EId));
    const typename PGraph::TObj::TEdgeI EI = Graph->GetEI(EId);
    if (! NewGraph.IsNode(EI.GetSrcNId())) {
      NewGraph.AddNode(Graph->GetNI(EI.GetSrcNId())); 
    }
    if (! NewGraph.IsNode(EI.GetDstNId())) {
      NewGraph.AddNode(Graph->GetNI(EI.GetDstNId())); 
    }
    NewGraph.AddEdge(EI);
  }
  return NewGraphPt;
}

template<class PGraph >

PGraph TSnap::GetESubGraph	(	const PGraph &	Graph,
		const TIntPrV &	EdgeV
	)

Definition at line 264 of file subgraph.h.

                                                               {
  PGraph NewGraphPt = PGraph::TObj::New();
  typename PGraph::TObj& NewGraph = *NewGraphPt;
  NewGraph.Reserve(-1, EdgeV.Len());

  for (int edge = 0; edge < EdgeV.Len(); edge++) {
    const int SrcNId = EdgeV[edge].Val1;
    const int DstNId = EdgeV[edge].Val2;
    if (! NewGraph.IsNode(SrcNId)) {
      NewGraph.AddNode(Graph->GetNI(SrcNId)); 
    }
    if (! NewGraph.IsNode(DstNId)) {
      NewGraph.AddNode(Graph->GetNI(DstNId)); 
    }

    NewGraph.AddEdge(SrcNId, DstNId);
  }
  return NewGraphPt;
}

template<class PGraph >

double TSnap::GetFarnessCentr	(	const PGraph &	Graph,
		const int &	NId,
		const bool &	Normalized = true,
		const bool &	IsDir = false
	)

Returns Farness centrality of a given node NId. Farness centrality of a node is the average shortest path length to all other nodes that reside is the same connected component as the given node.

Definition at line 123 of file centr.h.

                                                                                                       {
  TIntH NDistH(Graph->GetNodes());
  TSnap::GetShortPath<PGraph>(Graph, NId, NDistH, IsDir, TInt::Mx);  
  
  double sum = 0;
  for (TIntH::TIter I = NDistH.BegI(); I < NDistH.EndI(); I++) {
    sum += I->Dat();
  }
  if (NDistH.Len() > 1) { 
    double centr = sum/double(NDistH.Len()-1); 
    if (Normalized) {
      centr *= (Graph->GetNodes() - 1)/double(NDistH.Len()-1);
    }
    return centr;
  }
  else { return 0.0; }
}

template<class PGraph >

double TSnap::GetFarnessCentrMP	(	const PGraph &	Graph,
		const int &	NId,
		const bool &	Normalized = true,
		const bool &	IsDir = false
	)

Definition at line 142 of file centr.h.

                                                                                                         {
  TIntH NDistH(Graph->GetNodes());
  TSnap::GetShortPath<PGraph>(Graph, NId, NDistH, IsDir, TInt::Mx);  
  
  double sum = 0;
  for (TIntH::TIter I = NDistH.BegI(); I < NDistH.EndI(); I++) {
    sum += I->Dat();
  }
  if (NDistH.Len() > 1) { 
    double centr = sum/double(NDistH.Len()-1); 
    if (Normalized) {
      centr *= (Graph->GetNodes() - 1)/double(NDistH.Len()-1);
    }
    return centr;
  }
  else { return 0.0; }
}

TStr TSnap::GetFlagStr

(

const TGraphFlag &

GraphFlag

)

Returns a string representation of a flag.

Definition at line 5 of file gbase.cpp.

                                             {
  switch (GraphFlag) {
    case gfUndef : return "Undef";
    case gfDirected : return "Directed";
    case gfMultiGraph : return "Multigraph";
    case gfNodeDat : return "NodeDat";
    case gfEdgeDat : return "EdgeDat";
    case gfSources : return "Sources";
    case gfBipart : return "Bipartite";
    default: FailR("Unknown graph type");
  };
  return TStr();
}

template<class PGraph >

PGraph TSnap::GetGraphUnion	(	PGraph &	DstGraph,
		const PGraph &	SrcGraph
	)

Definition at line 764 of file subgraph.h.

                                                               {
  for (typename PGraph::TObj::TNodeI NI = SrcGraph->BegNI(); NI < SrcGraph->EndNI(); NI++) {
    if (! DstGraph->IsNode(NI.GetId())){
      DstGraph->AddNode(NI.GetId());
    }
  }
  for (typename PGraph::TObj::TEdgeI EI = SrcGraph->BegEI(); EI < SrcGraph->EndEI(); EI++) {
    if (! HasGraphFlag(typename PGraph::TObj, gfMultiGraph)){
      if (! DstGraph->IsEdge(EI.GetSrcNId(), EI.GetDstNId())){
        DstGraph->AddEdge(EI.GetSrcNId(), EI.GetDstNId());
      }
    }
    else{
      if (! DstGraph->IsEdge(EI.GetSrcNId(), EI.GetDstNId()) || ! DstGraph->IsEdge(EI.GetId())){
        if (! DstGraph->IsEdge(EI.GetId())){
          DstGraph->AddEdge(EI.GetSrcNId(), EI.GetDstNId(), EI.GetId());
        }else{
          DstGraph->AddEdge(EI.GetSrcNId(), EI.GetDstNId());
        }
      }
    }
  }
  return DstGraph;
}

PNEANet TSnap::GetGraphUnionAttr	(	PNEANet &	DstGraph,
		const PNEANet &	SrcGraph
	)

Definition at line 521 of file subgraph.cpp.

                                                                     {
  for (PNEANet::TObj::TNodeI NI = SrcGraph->BegNI(); NI < SrcGraph->EndNI(); NI++) {
    if (! DstGraph->IsNode(NI.GetId())){
      AddNodeWithAttributes(SrcGraph, DstGraph, NI.GetId());
    }
  }
  for (PNEANet::TObj::TEdgeI EI = SrcGraph->BegEI(); EI < SrcGraph->EndEI(); EI++) {
    if (! DstGraph->IsEdge(EI.GetSrcNId(), EI.GetDstNId()) || ! DstGraph->IsEdge(EI.GetId())){
      if (! DstGraph->IsEdge(EI.GetId())){
        AddEdgeWithAttributes(SrcGraph, DstGraph, EI.GetId());
      }else{
        AddEdgeWithAttributes(SrcGraph, DstGraph, EI.GetSrcNId(), EI.GetDstNId());
      }
    }
  }
  return DstGraph;
}

double TSnap::GetGroupClosenessCentr	(	const PUNGraph &	Graph,
		const TIntH &	GroupNodes
	)

Returns Group Degree centrality of a given group NId. Degree centrality if a node is defined as its degree/(N-1), where N is the number of nodes in the network.

Definition at line 169 of file centr.cpp.

                                                                              {
  const double Farness = GetGroupFarnessCentr(Graph, GroupNodes);
  if (Farness != 0.0) { return 1.0/Farness; }
  else { return 0.0; }
}

double TSnap::GetGroupDegreeCentr	(	const PUNGraph &	Graph,
		const PUNGraph &	Group
	)

Definition at line 59 of file centr.cpp.

                                                                         {
  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 TSnap::GetGroupDegreeCentr	(	const PUNGraph &	Graph,
		const TIntH &	GroupNodes
	)

Returns Group Degree centrality of a given group NId. Degree centrality if a node is defined as its degree/(N-1), where N is the number of nodes in the network.

Definition at line 85 of file centr.cpp.

                                                                           {
  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();
}

double TSnap::GetGroupDegreeCentr0	(	const PUNGraph &	Graph,
		const TIntH &	GroupNodes
	)

Definition at line 72 of file centr.cpp.

                                                                            {
  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();
}

double TSnap::GetGroupFarnessCentr	(	const PUNGraph &	Graph,
		const TIntH &	GroupNodes
	)

Definition at line 105 of file centr.cpp.

                                                                            {
  TIntH* NDistH = new TIntH[GroupNodes.Len()];
  
  for (int i=0; i<GroupNodes.Len(); i++){
    NDistH[i](Graph->GetNodes());
  TSnap::GetShortPath<PUNGraph>(Graph, GroupNodes.GetDat(i), NDistH[i], true, TInt::Mx);
  }

  int min, dist, sum=0, len=0;
  for (PUNGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++){
    if(NDistH[0].IsKey(NI.GetId()))
      min = NDistH[0].GetDat(NI.GetId());
    else
      min = -1;
    for (int j=1; j<GroupNodes.Len(); j++){
    if (NDistH[j].IsKey(NI.GetId()))
      dist = NDistH[j].GetDat(NI.GetId());
      else
      dist = -1;
    if ((dist < min && dist != -1) || (dist > min && min == -1))
      min = dist;
    }
    if (min>0){  
      sum += min;
      len++;
  }
    
  }

  if (len > 0) { return sum/double(len); }
  else { return 0.0; }
}

template<class PGraph >

void TSnap::GetHits	(	const PGraph &	Graph,
		TIntFltH &	NIdHubH,
		TIntFltH &	NIdAuthH,
		const int &	MaxIter = 20
	)

HITS: Hubs and Authorities For more info see: http://en.wikipedia.org/wiki/HITS_algorithm)

Definition at line 524 of file centr.h.

                                                                                             {
  const int NNodes = Graph->GetNodes();
  NIdHubH.Gen(NNodes);
  NIdAuthH.Gen(NNodes);
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    NIdHubH.AddDat(NI.GetId(), 1.0);
    NIdAuthH.AddDat(NI.GetId(), 1.0);
  }
  double Norm=0;
  for (int iter = 0; iter < MaxIter; iter++) {
    // update authority scores
    Norm = 0;
    for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
      double& Auth = NIdAuthH.GetDat(NI.GetId()).Val;
      Auth = 0;
      for (int e = 0; e < NI.GetInDeg(); e++) {
        Auth +=  NIdHubH.GetDat(NI.GetInNId(e)); }
      Norm += Auth*Auth;
    }
    Norm = sqrt(Norm);
    for (int i = 0; i < NIdAuthH.Len(); i++) { NIdAuthH[i] /= Norm; }
    // update hub scores
    for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
      double& Hub = NIdHubH.GetDat(NI.GetId()).Val;
      Hub = 0;
      for (int e = 0; e < NI.GetOutDeg(); e++) {
        Hub += NIdAuthH.GetDat(NI.GetOutNId(e)); }
      Norm += Hub*Hub;
    }
    Norm = sqrt(Norm);
    for (int i = 0; i < NIdHubH.Len(); i++) { NIdHubH[i] /= Norm; }
  }
  // make sure Hub and Authority scores normalize to L2 norm 1
  Norm = 0.0;
  for (int i = 0; i < NIdHubH.Len(); i++) { Norm += TMath::Sqr(NIdHubH[i]); }
  Norm = sqrt(Norm);
  for (int i = 0; i < NIdHubH.Len(); i++) { NIdHubH[i] /= Norm; }
  Norm = 0.0;
  for (int i = 0; i < NIdAuthH.Len(); i++) { Norm += TMath::Sqr(NIdAuthH[i]); }
  Norm = sqrt(Norm);
  for (int i = 0; i < NIdAuthH.Len(); i++) { NIdAuthH[i] /= Norm; }
}

template<class PGraph >

void TSnap::GetHitsMP	(	const PGraph &	Graph,
		TIntFltH &	NIdHubH,
		TIntFltH &	NIdAuthH,
		const int &	MaxIter = 20
	)

Definition at line 569 of file centr.h.

                                                                                               {
  const int NNodes = Graph->GetNodes();
  TIntV NV;
  NIdHubH.Gen(NNodes);
  NIdAuthH.Gen(NNodes);
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    NV.Add(NI.GetId());
    NIdHubH.AddDat(NI.GetId(), 1.0);
    NIdAuthH.AddDat(NI.GetId(), 1.0);
  }
  double Norm=0;
  for (int iter = 0; iter < MaxIter; iter++) {
    // update authority scores
    Norm = 0;
    #pragma omp parallel for reduction(+:Norm) schedule(dynamic,1000)
    for (int i = 0; i < NNodes; i++) {
      typename PGraph::TObj::TNodeI NI = Graph->GetNI(NV[i]);
      double& Auth = NIdAuthH.GetDat(NI.GetId()).Val;
      Auth = 0;
      for (int e = 0; e < NI.GetInDeg(); e++) {
        Auth +=  NIdHubH.GetDat(NI.GetInNId(e)); }
      Norm = Norm + Auth*Auth;
    }
    Norm = sqrt(Norm);
    for (int i = 0; i < NIdAuthH.Len(); i++) { NIdAuthH[i] /= Norm; }
    // update hub scores
    #pragma omp parallel for reduction(+:Norm) schedule(dynamic,1000)
    for (int i = 0; i < NNodes; i++) {
      typename PGraph::TObj::TNodeI NI = Graph->GetNI(NV[i]);
      double& Hub = NIdHubH.GetDat(NI.GetId()).Val;
      Hub = 0;
      for (int e = 0; e < NI.GetOutDeg(); e++) {
        Hub += NIdAuthH.GetDat(NI.GetOutNId(e)); }
      Norm = Norm + Hub*Hub;
    }
    Norm = sqrt(Norm);
    for (int i = 0; i < NIdHubH.Len(); i++) { NIdHubH[i] /= Norm; }
  }
  // make sure Hub and Authority scores normalize to L2 norm 1
  Norm = 0.0;
  for (int i = 0; i < NIdHubH.Len(); i++) { Norm += TMath::Sqr(NIdHubH[i]); }
  Norm = sqrt(Norm);
  for (int i = 0; i < NIdHubH.Len(); i++) { NIdHubH[i] /= Norm; }
  Norm = 0.0;
  for (int i = 0; i < NIdAuthH.Len(); i++) { Norm += TMath::Sqr(NIdAuthH[i]); }
  Norm = sqrt(Norm);
  for (int i = 0; i < NIdAuthH.Len(); i++) { NIdAuthH[i] /= Norm; }
}

template<class PGraph >

void TSnap::GetInDegCnt	(	const PGraph &	Graph,
		TIntPrV &	DegToCntV
	)

Returns an in-degree histogram: a set of pairs (in-degree, number of nodes of such in-degree)

Definition at line 179 of file alg.h.

                                                          {
  TIntH DegToCntH;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    DegToCntH.AddDat(NI.GetInDeg())++; }
  DegToCntV.Gen(DegToCntH.Len(), 0);
  for (int i = 0; i < DegToCntH.Len(); i++) {
    DegToCntV.Add(TIntPr(DegToCntH.GetKey(i), DegToCntH[i])); }
  DegToCntV.Sort();
}

template<class PGraph >

void TSnap::GetInDegCnt	(	const PGraph &	Graph,
		TFltPrV &	DegToCntV
	)

Returns an in-degree histogram: a set of pairs (in-degree, number of nodes of such in-degree)

Definition at line 190 of file alg.h.

                                                          {
  TIntH DegToCntH;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    DegToCntH.AddDat(NI.GetInDeg())++; }
  DegToCntV.Gen(DegToCntH.Len(), 0);
  for (int i = 0; i < DegToCntH.Len(); i++) {
    DegToCntV.Add(TFltPr(DegToCntH.GetKey(i).Val, DegToCntH[i].Val)); }
  DegToCntV.Sort();
}

PNEANet TSnap::GetInEgonetAttr	(	const PNEANet &	Graph,
		const int	CtrNId,
		const int	Radius
	)

Returns the in-egonet of at given radius and copies node and edge attributes.

Definition at line 342 of file subgraph.cpp.

                                                                                  {
  PNEANet NewGraphPt = PNEANet::New();
  TNEANet &NewGraph = *NewGraphPt;
  TSnapQueue<int> Queue1;
  TSnapQueue<int> Queue2;
  TSnapQueue<int> tempSwapQueue;
  AddNodeWithAttributes(Graph, NewGraphPt, CtrNId);
  Queue1.Clr(false);
  Queue1.Push(CtrNId);
  for (int r = 0; r < Radius; ++r) {
    while (!Queue1.Empty()) {
      const int NId = Queue1.Top();
      Queue1.Pop();
      const TNEANet::TNodeI &Node = Graph->GetNI(NId);
      for (int i = 0; i < Node.GetInDeg(); ++i) {
        const int InNId = Node.GetInNId(i);
        if (!NewGraph.IsNode(InNId)) {
          AddNodeWithAttributes(Graph, NewGraphPt, InNId);
          Queue2.Push(InNId);
        }
        const int InEId = Node.GetInEId(i);
        if (!NewGraph.IsEdge(InEId)) {
          AddEdgeWithAttributes(Graph, NewGraphPt, InEId);
        }
      }
      for (int i = 0; i < Node.GetInDeg(); ++i) {
        int InNId = Node.GetInNId(i);
        const TNEANet::TNodeI &InNode = Graph->GetNI(InNId);
        for (int j = 0; j < InNode.GetInDeg(); ++j) {
          int NbrInNId = InNode.GetInNId(j);
          if (NewGraph.IsNode(NbrInNId)) {
            const int NbrInEId = InNode.GetInEId(j);
            if (!NewGraph.IsEdge(NbrInEId)) {
              AddEdgeWithAttributes(Graph, NewGraphPt, NbrInEId);
            }
          }
        }
        for (int j = 0; j < InNode.GetOutDeg(); ++j) {
          int NbrOutNId = InNode.GetOutNId(j);
          if (NewGraph.IsNode(NbrOutNId)) {
            const int NbrOutEId = InNode.GetOutEId(j);
            if (!NewGraph.IsEdge(NbrOutEId)) {
              AddEdgeWithAttributes(Graph, NewGraphPt, NbrOutEId);
            }
          }
        }
      }
    }
    tempSwapQueue = Queue1;
    Queue1 = Queue2;
    Queue2 = tempSwapQueue;
  }
  return NewGraphPt;
}

template<class PGraph >

PGraph TSnap::GetInEgonetHop	(	const PGraph &	Graph,
		const int	CtrNId,
		const int	Radius
	)

Returns the in-egonet of node CtrNId as center in directed graph Graph for a given radius.

Definition at line 589 of file subgraph.h.

                                                                               {
  PGraph NewGraphPt = PGraph::TObj::New();
  typename PGraph::TObj& NewGraph = *NewGraphPt;
  TSnapQueue<int> Queue1;
  TSnapQueue<int> Queue2;
  TSnapQueue<int> tempSwapQueue;
  NewGraph.AddNode(CtrNId);
  Queue1.Clr(false);
  Queue1.Push(CtrNId);
  for (int r = 0; r < Radius; ++r) {
    while (!Queue1.Empty()) {
      const int NId = Queue1.Top();
      Queue1.Pop();
      const typename PGraph::TObj::TNodeI &Node = Graph->GetNI(NId);
      for (int i = 0; i < Node.GetInDeg(); ++i) {
        const int InNId = Node.GetInNId(i);
        if (!NewGraph.IsNode(InNId)) {
          NewGraph.AddNode(InNId);
          Queue2.Push(InNId);
        }
        if (!NewGraph.IsEdge(InNId, NId)) {
          NewGraph.AddEdge(InNId, NId);
        }
      }
      for (int i = 0; i < Node.GetInDeg(); ++i) {
        int InNId = Node.GetInNId(i);
        const typename PGraph::TObj::TNodeI &InNode = Graph->GetNI(InNId);
        for (int j = 0; j < InNode.GetInDeg(); ++j) {
          int NbrInNId = InNode.GetInNId(j);
          if (NewGraph.IsNode(NbrInNId)) {
            if (!NewGraph.IsEdge(NbrInNId, InNId)) {
              NewGraph.AddEdge(NbrInNId, InNId);
            }
          }
        }
        for (int j = 0; j < InNode.GetOutDeg(); ++j) {
          int NbrOutNId = InNode.GetOutNId(j);
          if (NewGraph.IsNode(NbrOutNId)) {
            if (!NewGraph.IsEdge(InNId, NbrOutNId)) {
              NewGraph.AddEdge(InNId, NbrOutNId);
            }
          }
        }
      }
    }
    tempSwapQueue = Queue1;
    Queue1 = Queue2;
    Queue2 = tempSwapQueue;
  }
  return NewGraphPt;
}

template<class PGraph >

PGraph TSnap::GetInEgonetSub	(	const PGraph &	Graph,
		const int	CtrNId,
		const int	Radius,
		const int	MaxNum = 2,
		const float	percent = -1.0
	)

Returns the randomly sampled in-egonet with nodes sampled based on percentage, if percent != -1.0, or MaxNum nodes otherwise.

Definition at line 695 of file subgraph.h.

                                                                                                                      {
  PGraph NewGraphPt = PGraph::TObj::New();
  typename PGraph::TObj& NewGraph = *NewGraphPt;
  TSnapQueue<int> Queue1;
  TSnapQueue<int> Queue2;
  TSnapQueue<int> tempSwapQueue;
  TSnapQueue<int> sampleQueue;
  NewGraph.AddNode(CtrNId);
  Queue1.Clr(false);
  Queue1.Push(CtrNId);
  bool usePercent = (percent != -1.0);
  int numSamples = MaxNum;
  for (int r = 0; r < Radius; ++r) {
    while (!Queue1.Empty()) {
      const int NId = Queue1.Top();
      Queue1.Pop();
      const typename PGraph::TObj::TNodeI &Node = Graph->GetNI(NId);
      sampleQueue.Clr(true);
      for (int i = 0; i < Node.GetInDeg(); ++i) {
        const int InNId = Node.GetInNId(i);
        if (!NewGraph.IsNode(InNId)) {
          sampleQueue.Push(InNId);
        }
      }
      if (usePercent) {
        numSamples = (int) (percent * sampleQueue.Len());
      }
      sampleQueue.Sample(numSamples);
      for (int i = 0; i < numSamples && !sampleQueue.Empty(); ++i) {
        const int InNId = sampleQueue.Top();
        sampleQueue.Pop();
        if (!NewGraph.IsNode(InNId)) {
          NewGraph.AddNode(InNId);
          Queue2.Push(InNId);
        }
        if (!NewGraph.IsEdge(InNId, NId)) {
          NewGraph.AddEdge(InNId, NId);
        }
      }
      for (int i = 0; i < Node.GetInDeg(); ++i) {
        int InNId = Node.GetInNId(i);
        if (!NewGraph.IsNode(InNId)) { continue; }
        const typename PGraph::TObj::TNodeI &InNode = Graph->GetNI(InNId);
        for (int j = 0; j < InNode.GetInDeg(); ++j) {
          int NbrInNId = InNode.GetInNId(j);
          if (NewGraph.IsNode(NbrInNId)) {
            if (!NewGraph.IsEdge(NbrInNId, InNId)) {
              NewGraph.AddEdge(NbrInNId, InNId);
            }
          }
        }
        for (int j = 0; j < InNode.GetOutDeg(); ++j) {
          int NbrOutNId = InNode.GetOutNId(j);
          if (NewGraph.IsNode(NbrOutNId)) {
            if (!NewGraph.IsEdge(InNId, NbrOutNId)) {
              NewGraph.AddEdge(InNId, NbrOutNId);
            }
          }
        }
      }
    }
    tempSwapQueue = Queue1;
    Queue1 = Queue2;
    Queue2 = tempSwapQueue;
  }
  return NewGraphPt;
}

PNEANet TSnap::GetInEgonetSubAttr	(	const PNEANet &	Graph,
		const int	CtrNId,
		const int	Radius,
		const int	MaxNum,
		const float	percent
	)

Returns the randomly sampled egonet with nodes sampled based on percentage or raw number, copying attributes.

Definition at line 453 of file subgraph.cpp.

                                                                                                                            {
  PNEANet NewGraphPt = TNEANet::New();
  TNEANet& NewGraph = *NewGraphPt;
  TSnapQueue<int> Queue1;
  TSnapQueue<int> Queue2;
  TSnapQueue<int> tempSwapQueue;
  TSnapQueue<int> sampleQueue;
  AddNodeWithAttributes(Graph, NewGraphPt, CtrNId);
  Queue1.Clr(false);
  Queue1.Push(CtrNId);
  bool usePercent = (percent != -1.0);
  int numSamples = MaxNum;
  for (int r = 0; r < Radius; ++r) {
    while (!Queue1.Empty()) {
      const int NId = Queue1.Top();
      Queue1.Pop();
      const TNEANet::TNodeI &Node = Graph->GetNI(NId);
      sampleQueue.Clr(true);
      for (int i = 0; i < Node.GetInDeg(); ++i) {
        const int InNId = Node.GetInNId(i);
        if (!NewGraph.IsNode(InNId)) {
          sampleQueue.Push(InNId);
        }
      }
      if (usePercent) {
        numSamples = (int) (percent * sampleQueue.Len());
      }
      sampleQueue.Sample(numSamples);
      for (int i = 0; i < numSamples && !sampleQueue.Empty(); ++i) {
        const int InNId = sampleQueue.Top();
        sampleQueue.Pop();
        if (!NewGraph.IsNode(InNId)) {
          AddNodeWithAttributes(Graph, NewGraphPt, InNId);
          Queue2.Push(InNId);
        }
        if (!NewGraph.IsEdge(InNId, NId)) {
          AddEdgeWithAttributes(Graph, NewGraphPt, InNId, NId);
        }
      }
      for (int i = 0; i < Node.GetInDeg(); ++i) {
        int InNId = Node.GetInNId(i);
        if (!NewGraph.IsNode(InNId)) { continue; }
        const TNEANet::TNodeI &InNode = Graph->GetNI(InNId);
        for (int j = 0; j < InNode.GetInDeg(); ++j) {
          int NbrInNId = InNode.GetInNId(j);
          if (NewGraph.IsNode(NbrInNId)) {
            if (!NewGraph.IsEdge(NbrInNId, InNId)) {
              AddEdgeWithAttributes(Graph, NewGraphPt, NbrInNId, InNId);
            }
          }
        }
        for (int j = 0; j < InNode.GetOutDeg(); ++j) {
          int NbrOutNId = InNode.GetOutNId(j);
          if (NewGraph.IsNode(NbrOutNId)) {
            if (!NewGraph.IsEdge(InNId, NbrOutNId)) {
              AddEdgeWithAttributes(Graph, NewGraphPt, InNId, NbrOutNId);
            }
          }
        }
      }
    }
    tempSwapQueue = Queue1;
    Queue1 = Queue2;
    Queue2 = tempSwapQueue;
  }
  return NewGraphPt;
}

void TSnap::GetInvParticipRat	(	const PUNGraph &	Graph,
		int	MaxEigVecs,
		int	TimeLimit,
		TFltPrV &	EigValIprV
	)

Computes Inverse participation ratio of a given graph. See Spectra of "real-world" graphs: Beyond the semicircle law by Farkas, Derenyi, Barabasi and Vicsek

Definition at line 378 of file gsvd.cpp.

                                                                                                  {
  TUNGraphMtx GraphMtx(Graph);
  TFltVV EigVecVV;
  TFltV EigValV;
  TExeTm ExeTm;
  if (MaxEigVecs<=1) { MaxEigVecs=1000; }
  int EigVecs = TMath::Mn(Graph->GetNodes(), MaxEigVecs);
  printf("start %d vecs...", EigVecs);
  try {
    TSparseSVD::Lanczos2(GraphMtx, EigVecs, TimeLimit, ssotFull, EigValV, EigVecVV, false);
  } catch(...) {
    printf("\n  ***EXCEPTION:  TRIED %d GOT %d values** \n", EigVecs, EigValV.Len()); }
  printf("  ***TRIED %d GOT %d values in %s\n", EigVecs, EigValV.Len(), ExeTm.GetStr());
  TFltV EigVec;
  EigValIprV.Clr();
  if (EigValV.Empty()) { return; }
  for (int v = 0; v < EigVecVV.GetCols(); v++) {
    EigVecVV.GetCol(v, EigVec);
    EigValIprV.Add(TFltPr(EigValV[v], TSnapDetail::GetInvParticipRatEig(EigVec)));
  }
  EigValIprV.Sort();
}

template<class PGraph >

PGraph TSnap::GetKCore	(	const PGraph &	Graph,
		const int &	K
	)

Returns the K-core of a graph. If the core of order K does not exist the function returns an empty graph.

Definition at line 106 of file kcore.h.

                                                   {
  TKCore<PGraph> KCore(Graph);
  KCore.GetCoreK(K);
  return TSnap::GetSubGraph(Graph, KCore.GetNIdV());
}

template<class PGraph >

int TSnap::GetKCoreEdges	(	const PGraph &	Graph,
		TIntPrV &	CoreIdSzV
	)

Returns the number of edges in each core of order K (where K=0, 1, ...)

Definition at line 126 of file kcore.h.

                                                           {
  TKCore<PGraph> KCore(Graph);
  CoreIdSzV.Clr();
  CoreIdSzV.Add(TIntPr(0, Graph->GetEdges()));
  for (int i = 1; KCore.GetNextCore() > 0; i++) {
    CoreIdSzV.Add(TIntPr(i, KCore.GetCoreEdges()));
  }
  return KCore.GetCurK();
}

template<class PGraph >

int TSnap::GetKCoreNodes	(	const PGraph &	Graph,
		TIntPrV &	CoreIdSzV
	)

Returns the number of nodes in each core of order K (where K=0, 1, ...)

Definition at line 114 of file kcore.h.

                                                           {
  TKCore<PGraph> KCore(Graph);
  CoreIdSzV.Clr();
  CoreIdSzV.Add(TIntPr(0, Graph->GetNodes()));
  for (int i = 1; KCore.GetNextCore() > 0; i++) {
    CoreIdSzV.Add(TIntPr(i, KCore.GetCoreNodes()));
  }
  return KCore.GetCurK();
}

template<class PGraph >

int TSnap::GetLen2Paths	(	const PGraph &	Graph,
		const int &	NId1,
		const int &	NId2
	)

Returns the number of length 2 directed paths between a pair of nodes NId1, NId2 (NId1 –> U –> NId2).

Definition at line 761 of file triad.h.

                                                                        {
  TIntV NbrV;
  return GetLen2Paths(Graph, NId1, NId2, NbrV);
}

template<class PGraph >

int TSnap::GetLen2Paths	(	const PGraph &	Graph,
		const int &	NId1,
		const int &	NId2,
		TIntV &	NbrV
	)

Returns the 2 directed paths between a pair of nodes NId1, NId2 (NId1 –> U –> NId2).

NbrV intermediary stores nodes U.

Definition at line 769 of file triad.h.

                                                                                     {
  const typename PGraph::TObj::TNodeI NI = Graph->GetNI(NId1);
  NbrV.Clr(false);
  NbrV.Reserve(NI.GetOutDeg());
  for (int e = 0; e < NI.GetOutDeg(); e++) {
    const typename PGraph::TObj::TNodeI MidNI = Graph->GetNI(NI.GetOutNId(e));
    if (MidNI.IsOutNId(NId2)) {
      NbrV.Add(MidNI.GetId());
    }
  }
  return NbrV.Len();
}

TTableIterator TSnap::GetMapHitsIterator	(	const TVec< PNEANet > &	GraphSeq,
		TTableContext *	Context,
		const int &	MaxIter = 20
	)

Gets sequence of Hits tables from given GraphSeq.

Definition at line 917 of file centr.cpp.

                             {
  TVec<PTable> TableSeq(GraphSeq.Len());
  TSnap::MapHits(GraphSeq, TableSeq, Context, MaxIter);
  return TTableIterator(TableSeq);
}

TTableIterator TSnap::GetMapPageRank	(	const TVec< PNEANet > &	GraphSeq,
		TTableContext *	Context,
		const double &	C = 0.85,
		const double &	Eps = 1e-4,
		const int &	MaxIter = 100
	)

Gets sequence of PageRank tables from given GraphSeq.

Definition at line 907 of file centr.cpp.

                                                                                {
  TVec<PTable> TableSeq(GraphSeq.Len());
  TSnap::MapPageRank(GraphSeq, TableSeq, Context, C, Eps, MaxIter);
  return TTableIterator(TableSeq);
}

int TSnap::GetMaxFlowIntEK	(	PNEANet &	Net,
		const int &	SrcNId,
		const int &	SnkNId
	)

Returns the maximum integer valued flow in the network Net from source SrcNId to sink SnkNId.

Implements max flow using the Edmonds-Karp algorithm. http://en.wikipedia.org/wiki/Edmonds%E2%80%93Karp_algorithm Although the asymptotic run time of Edmonds-Karp is worse than that of Push Relabel, in practice Edmonds Karp works very well, especially if the network is sparse. Unless the degree of each node is on the order of the number of nodes, it is best to use Edmonds Karp over Push Relabel.

Definition at line 105 of file flow.cpp.

                                                                         {
  IAssert(Net->IsNode(SrcNId));
  IAssert(Net->IsNode(SnkNId));
  if (SrcNId == SnkNId) { return 0; }
  int CapIndex = Net->GetIntAttrIndE(CapAttrName);
  TIntV Flow(Net->GetMxEId());
  // Initialize flow values to 0, and make sure capacities are nonnegative
  for (TNEANet::TEdgeI EI = Net->BegEI(); EI != Net->EndEI(); EI++) {
    IAssert(Net->GetIntAttrIndDatE(EI, CapIndex) >= 0);
    Flow[EI.GetId()] = 0;
  }
  // Return 0 if user attempts to flow from a node to itself.
  if (SrcNId == SnkNId) { return 0; }
  int MaxFlow = 0, MinAug, CurNId;
  while (true) {
    TIntV MidToSrcAugV; TIntV MidToSnkAugV;
    TIntQ FwdNodeQ; TIntQ BwdNodeQ;
    TIntH PredEdgeH; TIntH SuccEdgeH;
    MinAug = FindAugV(Net, CapIndex, Flow, FwdNodeQ, PredEdgeH, BwdNodeQ, SuccEdgeH, MidToSrcAugV, MidToSnkAugV, SrcNId, SnkNId);
    if (MinAug == 0) { break; }
    MaxFlow += MinAug;
    CurNId = SrcNId;
    for (int i = MidToSrcAugV.Len() - 1; i >= 0; i--) {
      int NextEId = MidToSrcAugV[i];
      const TNEANet::TEdgeI &EI = Net->GetEI(NextEId);
      if (EI.GetSrcNId() == CurNId) {
        Flow[NextEId] += MinAug;
        CurNId = EI.GetDstNId();
      } else {
        Flow[NextEId] -= MinAug;
        CurNId = EI.GetSrcNId();
      }
    }
    for (int i = 0; i < MidToSnkAugV.Len(); i++) {
      int NextEId = MidToSnkAugV[i];
      const TNEANet::TEdgeI &EI = Net->GetEI(NextEId);
      if (EI.GetSrcNId() == CurNId) {
        Flow[NextEId] += MinAug;
        CurNId = EI.GetDstNId();
      } else {
        Flow[NextEId] -= MinAug;
        CurNId = EI.GetSrcNId();
      }
    }
  }
  return MaxFlow;
}

int TSnap::GetMaxFlowIntPR	(	PNEANet &	Net,
		const int &	SrcNId,
		const int &	SnkNId
	)

Returns the maximum integer valued flow in the network Net from source SrcNId to sink SnkNId.

Implements max flow using the Edmonds-Karp algorithm. http://en.wikipedia.org/wiki/Edmonds%E2%80%93Karp_algorithm Although the asymptotic run time of Edmonds-Karp is worse than that of Push Relabel, in practice Edmonds Karp works very well, especially if the network is sparse. Unless the degree of each node is on the order of the number of nodes, it is best to use Edmonds Karp over Push Relabel.

Definition at line 410 of file flow.cpp.

                                                                         {
  IAssert(Net->IsNode(SrcNId));
  IAssert(Net->IsNode(SnkNId));
  if (SrcNId == SnkNId) { return 0; }

  TPRManager PRM(Net);
  int MaxLabel = PRM.GetMaxLabel();

  TNEANet::TNodeI SrcNI = Net->GetNI(SrcNId);
  for (int EdgeN = 0; EdgeN < SrcNI.GetOutDeg(); EdgeN++) {
    int EId = SrcNI.GetOutEId(EdgeN);
    int OutNId = SrcNI.GetOutNId(EdgeN);
    if (OutNId != SrcNId) {
      int Capacity = PRM.Capacity(EId);
      PRM.Flow(EId) = Capacity;
      PRM.Excess(OutNId) = Capacity;
    }
  }
  GlobalRelabel(Net, PRM, SrcNId, SnkNId);
  PRM.SetLabel(SrcNId, MaxLabel);
  int RelabelCount = 1;
  int GRRate = Net->GetNodes();
  while (PRM.HasActive()) {
    int NId = PRM.PopActive();
    const TNEANet::TNodeI &NI = Net->GetNI(NId);
    int PrevLabel = MaxLabel;
    while (PRM.Excess(NId) > 0 && PRM.Label(NId) <= PrevLabel) {
      PrevLabel = PRM.Label(NId);
      int NbrNId = PushRelabel(PRM, NId, NI);
      if (NbrNId != -1 && NbrNId != SnkNId && PRM.Excess(NbrNId) > 0 && !PRM.IsActive(NbrNId)) {
        PRM.PushActive(NbrNId);
      }
    }
    if (PRM.Excess(NId) > 0 && PRM.Label(NId) < MaxLabel) {
      PRM.PushActive(NId);
    }
    if (RelabelCount % GRRate == 0) { GlobalRelabel(Net, PRM, SrcNId, SnkNId); }
  }
  return PRM.Excess(SnkNId);
}

template<typename PGraph >

double TSnap::GetModularity	(	const PGraph &	G,
		const TIntV &	NIdV,
		int	GEdges = -1
	)

Computes Modularity score of a set of nodes NIdV in a graph G. The function runs much faster if the number of edges in graph G is given (GEdges parameter).

Definition at line 46 of file cmty.h.

                                                                         {
  if (GEdges == -1) { GEdges = Graph->GetEdges(); }
  double EdgesIn = 0.0, EEdgesIn = 0.0; // EdgesIn=2*number of edges inside the cluster, EEdgesIn=expected edges inside
  TIntSet NIdSet(NIdV.Len());
  for (int e = 0; e < NIdV.Len(); e++) { // edges inside
    NIdSet.AddKey(NIdV[e]);
  }
  for (int e1 = 0; e1 < NIdV.Len(); e1++) {
    typename PGraph::TObj::TNodeI NI = Graph->GetNI(NIdV[e1]);
    EEdgesIn += NI.GetOutDeg();
    for (int i = 0; i < NI.GetOutDeg(); i++) {
      if (NIdSet.IsKey(NI.GetOutNId(i))) { EdgesIn += 1; }
    }
  }
  EEdgesIn = EEdgesIn*EEdgesIn / (2.0*GEdges);
  if ((EdgesIn - EEdgesIn) == 0) { return 0; }
  else { return (EdgesIn - EEdgesIn) / (2.0*GEdges); } // modularity
}

template<typename PGraph >

double TSnap::GetModularity	(	const PGraph &	G,
		const TCnComV &	CmtyV,
		int	GEdges = -1
	)

Computes Modularity score of a set of communities (each community is defined by its member nodes) in a graph G. The function runs much faster if the number of edges in graph G is given (GEdges parameter).

Definition at line 66 of file cmty.h.

                                                                        {
  if (GEdges == -1) { GEdges = G->GetEdges(); }
  double Modularity = 0;
  for (int c = 0; c < CmtyV.Len(); c++) {
    Modularity += GetModularity(G, CmtyV[c](), GEdges);
  }
  return Modularity;
}

template<class PGraph >

PGraph TSnap::GetMxBiCon

(

const PGraph &

Graph

)

Returns a graph representing the largest bi-connected component on an input Graph.

An undirected graph is bi-connected if by removing any single node does not disconnect the graph. http://en.wikipedia.org/wiki/Biconnected_component

Definition at line 486 of file cncom.h.

                                       {
  TCnComV CnComV;
  GetBiCon(TSnap::ConvertGraph<PUNGraph, PGraph>(Graph), CnComV);
  if (CnComV.Empty()) { return PGraph::TObj::New(); }
  int CcId = 0, MxSz = 0;
  for (int i = 0; i < CnComV.Len(); i++) {
    if (MxSz < CnComV[i].Len()) {
      MxSz=CnComV[i].Len();  CcId=i; }
  }
  if (CnComV[CcId].Len()==Graph->GetNodes()) { 
    return Graph; }
  else { 
    return TSnap::GetSubGraph(Graph, CnComV[CcId]()); 
  }
}

PUNGraph TSnap::GetMxBiCon	(	const PUNGraph &	Graph,
		const bool &	RenumberNodes = false
	)

Returns a graph representing the largest bi-connected component on an undirected Graph.

An undirected graph is bi-connected if by removing any single node does not disconnect the graph. http://en.wikipedia.org/wiki/Biconnected_component

Definition at line 126 of file cncom.cpp.

                                                                      {
  TCnComV CnComV;
  GetBiCon(Graph, CnComV);
  if (CnComV.Empty()) { 
    return PUNGraph(); 
  }
  int CcId = 0, MxSz = 0;
  for (int i = 0; i < CnComV.Len(); i++) {
    if (MxSz < CnComV[i].Len()) {
      MxSz = CnComV[i].Len();  
      CcId=i; 
    }
  }
  return TSnap::GetSubGraph(Graph, CnComV[CcId](), RenumberNodes);
}

template<class PGraph >

int TSnap::GetMxDegNId

(

const PGraph &

Graph

)

Returns a randomly chosen node from all the nodes with the maximum degree.

Definition at line 143 of file alg.h.

                                     {
  TIntV MxDegV;
  int MxDeg=-1;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (MxDeg < NI.GetDeg()) { MxDegV.Clr(); MxDeg = NI.GetDeg(); }
    if (MxDeg == NI.GetDeg()) { MxDegV.Add(NI.GetId()); }
  }
  EAssertR(! MxDegV.Empty(), "Input graph is empty!");
  return MxDegV[TInt::Rnd.GetUniDevInt(MxDegV.Len())];
}

template<class PGraph >

int TSnap::GetMxInDegNId

(

const PGraph &

Graph

)

Returns a randomly chosen node from all the nodes with the maximum in-degree.

Definition at line 155 of file alg.h.

                                       {
  TIntV MxDegV;
  int MxDeg=-1;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (MxDeg < NI.GetInDeg()) { MxDegV.Clr(); MxDeg = NI.GetInDeg(); }
    if (MxDeg == NI.GetInDeg()) { MxDegV.Add(NI.GetId()); }
  }
  EAssertR(! MxDegV.Empty(), "Input graph is empty!");
  return MxDegV[TInt::Rnd.GetUniDevInt(MxDegV.Len())];
}

template<class PGraph >

int TSnap::GetMxOutDegNId

(

const PGraph &

Graph

)

Returns a randomly chosen node from all the nodes with the maximum out-degree.

Definition at line 167 of file alg.h.

                                        {
  TIntV MxDegV;
  int MxDeg=-1;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (MxDeg < NI.GetOutDeg()) { MxDegV.Clr(); MxDeg = NI.GetOutDeg(); }
    if (MxDeg == NI.GetOutDeg()) { MxDegV.Add(NI.GetId()); }
  }
  EAssertR(! MxDegV.Empty(), "Input graph is empty!");
  return MxDegV[TInt::Rnd.GetUniDevInt(MxDegV.Len())];
}

template<class PGraph >

PGraph TSnap::GetMxScc

(

const PGraph &

Graph

)

Returns a graph representing the largest strongly connected component on an input Graph.

A directed graph is strongly connected if there exists a directed path from any vertex to any other vertex in the graph. See http://en.wikipedia.org/wiki/Strongly_connected_component

Definition at line 469 of file cncom.h.

                                     {
  TCnComV CnComV;
  GetSccs(Graph, CnComV);
  if (CnComV.Empty()) { return PGraph::TObj::New(); }
  int CcId = 0, MxSz = 0;
  for (int i = 0; i < CnComV.Len(); i++) {
    if (MxSz < CnComV[i].Len()) {
      MxSz=CnComV[i].Len();  CcId=i; }
  }
  if (CnComV[CcId].Len()==Graph->GetNodes()) { 
    return Graph; }
  else { 
    return TSnap::GetSubGraph(Graph, CnComV[CcId]()); 
  }
}

template<class PGraph >

double TSnap::GetMxSccSz

(

const PGraph &

Graph

)

Returns the fraction of nodes in the largest strongly connected component of a Graph.

Definition at line 444 of file cncom.h.

                                       {
  TCnComV CnComV;
  GetSccs(Graph, CnComV);
  if (Graph->GetNodes() == 0) { return 0; }
  else { return CnComV[0].Len() / double(Graph->GetNodes()); }
}

template<class PGraph >

PGraph TSnap::GetMxWcc

(

const PGraph &

Graph

)

Returns a graph representing the largest weakly connected component on an input Graph.

A directed/undirected graph is connected if there exist an undirected path between any pair of nodes. See http://en.wikipedia.org/wiki/Connected_component_(graph_theory)

Definition at line 452 of file cncom.h.

                                     {
  TCnComV CnComV;
  GetWccs(Graph, CnComV);
  if (CnComV.Empty()) { return PGraph::TObj::New(); }
  int CcId = 0, MxSz = 0;
  for (int i = 0; i < CnComV.Len(); i++) {
    if (MxSz < CnComV[i].Len()) {
      MxSz=CnComV[i].Len();  CcId=i; }
  }
  if (CnComV[CcId].Len()==Graph->GetNodes()) { 
    return Graph; }
  else { 
    return TSnap::GetSubGraph(Graph, CnComV[CcId]()); 
  }
}

template<class PGraph >

double TSnap::GetMxWccSz

(

const PGraph &

Graph

)

Returns the fraction of nodes in the largest weakly connected component of a Graph.

Definition at line 436 of file cncom.h.

                                       {
  TCnComV CnComV;
  GetWccs(Graph, CnComV);
  if (Graph->GetNodes() == 0) { return 0; }
  else { return CnComV[0].Len() / double(Graph->GetNodes()); }
}

template<class PGraph >

double TSnap::GetNodeClustCf	(	const PGraph &	Graph,
		const int &	NId
	)

Returns clustering coefficient of a particular node.

Considers the graph as undirected.

Definition at line 220 of file triad.h.

                                                           {
  int Open, Closed;
  GetNodeTriads(Graph, NId, Open, Closed);
  //const double Deg = Graph->GetNI(NId).GetDeg();
  return (Open+Closed)==0 ? 0 : double(Open)/double(Open+Closed);
}

template<class PGraph >

void TSnap::GetNodeClustCf	(	const PGraph &	Graph,
		TIntFltH &	NIdCCfH
	)

Computes clustering coefficient of each node of the Graph.

Considers the graph as undirected.

Definition at line 228 of file triad.h.

                                                            {
  TIntTrV NIdCOTriadV;
  GetTriads(Graph, NIdCOTriadV);
  NIdCCfH.Clr(false);
  for (int i = 0; i < NIdCOTriadV.Len(); i++) {
    const int D = NIdCOTriadV[i].Val2()+NIdCOTriadV[i].Val3();
    const double CCf = D!=0 ? NIdCOTriadV[i].Val2() / double(D) : 0.0;
    NIdCCfH.AddDat(NIdCOTriadV[i].Val1, CCf);
  }
}

template<class PGraph >

int TSnap::GetNodeEcc	(	const PGraph &	Graph,
		const int &	NId,
		const bool &	IsDir = false
	)

Returns node Eccentricity, the largest shortest-path distance from the node NId to any other node in the Graph.

Parameters

IsDir

false: ignore edge directions and consider edges as undirected (in case they are directed).

Definition at line 177 of file centr.h.

                                                                       {
  int NodeEcc;
  int Dist;
  TBreathFS<PGraph> BFS(Graph);
  // get shortest paths to all the nodes
  BFS.DoBfs(NId, true, ! IsDir, -1, TInt::Mx);

  NodeEcc = 0;
  // find the largest value
  for (int i = 0; i < BFS.NIdDistH.Len(); i++) {
    Dist = BFS.NIdDistH[i];
    if (Dist > NodeEcc) {
      NodeEcc = Dist;
    }
  }
  return NodeEcc;
}

template<class PGraph >

void TSnap::GetNodeInDegV	(	const PGraph &	Graph,
		TIntPrV &	NIdInDegV
	)

Returns a vector of pairs (node id, node in-degree)

Definition at line 263 of file alg.h.

                                                            {
  NIdInDegV.Reserve(Graph->GetNodes(), 0);
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    NIdInDegV.Add(TIntPr(NI.GetId(), NI.GetInDeg()));
  }
}

template<class PGraph >

void TSnap::GetNodeOutDegV	(	const PGraph &	Graph,
		TIntPrV &	NIdOutDegV
	)

Returns a vector of pairs (node id, node out-degree)

Definition at line 271 of file alg.h.

                                                              {
  NIdOutDegV.Reserve(Graph->GetNodes(), 0);
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    NIdOutDegV.Add(TIntPr(NI.GetId(), NI.GetOutDeg()));
  }
}

template<class PGraph >

int TSnap::GetNodesAtHop	(	const PGraph &	Graph,
		const int &	StartNId,
		const int &	Hop,
		TIntV &	NIdV,
		const bool &	IsDir = false
	)

Finds IDs of all nodes that are at distance Hop from node StartNId.

false: ignore edge directions and consider edges/paths as undirected (in case they are directed).

Definition at line 375 of file bfsdfs.h.

                                                                                                            {
  TBreathFS<PGraph> BFS(Graph);
  BFS.DoBfs(StartNId, true, !IsDir, -1, Hop);
  NIdV.Clr(false);
  for (int i = 0; i < BFS.NIdDistH.Len(); i++) {
    if (BFS.NIdDistH[i] == Hop) {
      NIdV.Add(BFS.NIdDistH.GetKey(i)); }
  }
  return NIdV.Len();
}

template<class PGraph >

int TSnap::GetNodesAtHops	(	const PGraph &	Graph,
		const int &	StartNId,
		TIntPrV &	HopCntV,
		const bool &	IsDir = false
	)

Returns the number of nodes at each hop distance from the starting node StartNId.

false: ignore edge directions and consider edges/paths as undirected (in case they are directed).

Definition at line 387 of file bfsdfs.h.

                                                                                                  {
  TBreathFS<PGraph> BFS(Graph);
  BFS.DoBfs(StartNId, true, !IsDir, -1, TInt::Mx);
  TIntH HopCntH;
  for (int i = 0; i < BFS.NIdDistH.Len(); i++) {
    HopCntH.AddDat(BFS.NIdDistH[i]) += 1;
  }
  HopCntH.GetKeyDatPrV(HopCntV);
  HopCntV.Sort();
  return HopCntV.Len();
}

template<class PGraph >

int TSnap::GetNodeTriads	(	const PGraph &	Graph,
		const int &	NId
	)

Returns the number of undirected triads a node NId participates in.

Considers the graph as undirected.

Parameters

Graph	Input graph
NId	Input node

Definition at line 615 of file triad.h.

                                                       {
  int ClosedTriads=0, OpenTriads=0;
  return GetNodeTriads(Graph, NId, ClosedTriads, OpenTriads);
}

template<class PGraph >

int TSnap::GetNodeTriads	(	const PGraph &	Graph,
		const int &	NId,
		int &	ClosedNTriadsX,
		int &	OpenNTriadsX
	)

Returns number of Open and Closed triads a node NId participates in.

Considers the graph as undirected.

Parameters

Graph	Input graph
NId	Input node
ClosedNTriadsX	On return contains the number of closed triads.
OpenNTriadsX	On return contains the number of open triads.

Definition at line 622 of file triad.h.

                                                                                           {
  const typename PGraph::TObj::TNodeI NI = Graph->GetNI(NId);
  ClosedTriads=0;  OpenTriads=0;
  if (NI.GetDeg() < 2) { return 0; }
  // find neighborhood
  TIntSet NbrSet(NI.GetDeg());
  for (int e = 0; e < NI.GetOutDeg(); e++) {
    if (NI.GetOutNId(e) != NI.GetId()) { // exclude self edges
      NbrSet.AddKey(NI.GetOutNId(e)); }
  }
  if (Graph->HasFlag(gfDirected)) {
    for (int e = 0; e < NI.GetInDeg(); e++) {
      if (NI.GetInNId(e) != NI.GetId()) { // exclude self edges
        NbrSet.AddKey(NI.GetInNId(e)); }
    }
  }
  // count connected neighbors
  for (int srcNbr = 0; srcNbr < NbrSet.Len(); srcNbr++) {
    const typename PGraph::TObj::TNodeI SrcNode = Graph->GetNI(NbrSet.GetKey(srcNbr));
    for (int dstNbr = srcNbr+1; dstNbr < NbrSet.Len(); dstNbr++) {
      const int dstNId = NbrSet.GetKey(dstNbr);
      if (SrcNode.IsNbrNId(dstNId)) { ClosedTriads++; }
      else { OpenTriads++; }
    }
  }
  return ClosedTriads;
}

template<class PGraph >

int TSnap::GetNodeTriads	(	const PGraph &	Graph,
		const int &	NId,
		const TIntSet &	GroupSet,
		int &	InGroupEdgesX,
		int &	InOutGroupEdgesX,
		int &	OutGroupEdgesX
	)

Returns the number of triads between a node NId and a subset of its neighbors GroupSet.

Considers the graph as undirected.

Parameters

Graph	Input graph
NId	Input node
GroupSet	Input set with node neighbors
InGroupEdgesX	On return contains the number of triads (NId, G1, G2), where G1 and G2 are in GroupSet.
InOutGroupEdgesX	On return contains the number of triads (NId, G1, O1), where G1 is in GroupSet and O1 not in GroupSet.
OutGroupEdgesX	On return contains the number of triads (NId, O1, O2), where O1 and O2 are not in GroupSet.

Definition at line 660 of file triad.h.

                                                                                                                                             {
  const typename PGraph::TObj::TNodeI NI = Graph->GetNI(NId);
  const bool IsDir = Graph->HasFlag(gfDirected);
  InGroupEdges=0;  InOutGroupEdges=0;  OutGroupEdges=0;
  if (NI.GetDeg() < 2) { return 0; }
  // find neighborhood
  TIntSet NbrSet(NI.GetDeg());
  for (int e = 0; e < NI.GetOutDeg(); e++) {
    if (NI.GetOutNId(e) != NI.GetId()) { // exclude self edges
      NbrSet.AddKey(NI.GetOutNId(e)); }
  }
  if (IsDir) {
    for (int e = 0; e < NI.GetInDeg(); e++) {
      if (NI.GetInNId(e) != NI.GetId()) {
        NbrSet.AddKey(NI.GetInNId(e)); }
    }
  }
  // count connected neighbors
  for (int srcNbr = 0; srcNbr < NbrSet.Len(); srcNbr++) {
    const int NbrId = NbrSet.GetKey(srcNbr);
    const bool NbrIn = GroupSet.IsKey(NbrId);
    const typename PGraph::TObj::TNodeI SrcNode = Graph->GetNI(NbrId);
    for (int dstNbr = srcNbr+1; dstNbr < NbrSet.Len(); dstNbr++) {
      const int DstNId = NbrSet.GetKey(dstNbr);
      if (SrcNode.IsNbrNId(DstNId)) { // triad (NId, NbrId, DstNid)
        bool DstIn = GroupSet.IsKey(DstNId);
        if (NbrIn && DstIn) { InGroupEdges++; }
        else if (NbrIn || DstIn) { InOutGroupEdges++; }
        else { OutGroupEdges++; }
      }
    }
  }
  return InGroupEdges;
}

template<class PGraph >

int TSnap::GetNodeTriadsAll	(	const PGraph &	Graph,
		const int &	NId,
		int &	ClosedNTriadsX,
		int &	OpenNTriadsX
	)

Returns number of Open and Closed triads a node NId participates in.

Considers the graph as undirected. This function is a duplicate. It is required by Snap.py.

Parameters

Graph	Input graph
NId	Input node
ClosedNTriadsX	On return contains the number of closed triads.
OpenNTriadsX	On return contains the number of open triads.

Definition at line 651 of file triad.h.

                                                                                              {
  return GetNodeTriads(Graph, NId, ClosedTriads, OpenTriads);
}

template<class PGraph >

void TSnap::GetNodeWcc	(	const PGraph &	Graph,
		const int &	NId,
		TIntV &	CnCom
	)

Returns (via output parameter CnCom) all nodes that are in the same connected component as node NId.

Definition at line 277 of file cncom.h.

                                                                   {
  typename PGraph::TObj::TNodeI NI;
  THashSet<TInt> VisitedNId(Graph->GetNodes()+1);
  TSnapQueue<int> NIdQ(Graph->GetNodes()+1);
  VisitedNId.AddKey(NId);
  NIdQ.Push(NId);
  while (! NIdQ.Empty()) {
    const typename PGraph::TObj::TNodeI Node = Graph->GetNI(NIdQ.Top());  NIdQ.Pop();
    if (HasGraphFlag(typename PGraph::TObj, gfDirected)) {
      for (int e = 0; e < Node.GetInDeg(); e++) {
        const int InNId = Node.GetInNId(e);
        if (! VisitedNId.IsKey(InNId)) {
          NIdQ.Push(InNId);  VisitedNId.AddKey(InNId); }
      }
    }
    for (int e = 0; e < Node.GetOutDeg(); e++) {
      const int OutNId = Node.GetOutNId(e);
      if (! VisitedNId.IsKey(OutNId)) {
        NIdQ.Push(OutNId);  VisitedNId.AddKey(OutNId); }
    }
  }
  CnCom.Gen(VisitedNId.Len(), 0);
  for (int i = 0; i < VisitedNId.Len(); i++) {
    CnCom.Add(VisitedNId.GetKey(i));
  }
}

template<class PGraph >

void TSnap::GetOutDegCnt	(	const PGraph &	Graph,
		TIntPrV &	DegToCntV
	)

Returns an out-degree histogram: a set of pairs (out-degree, number of nodes of such out-degree)

Definition at line 201 of file alg.h.

                                                           {
  TIntH DegToCntH;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    DegToCntH.AddDat(NI.GetOutDeg())++; }
  DegToCntV.Gen(DegToCntH.Len(), 0);
  for (int i = 0; i < DegToCntH.Len(); i++) {
    DegToCntV.Add(TIntPr(DegToCntH.GetKey(i), DegToCntH[i])); }
  DegToCntV.Sort();
}

template<class PGraph >

void TSnap::GetOutDegCnt	(	const PGraph &	Graph,
		TFltPrV &	DegToCntV
	)

Returns an out-degree histogram: a set of pairs (out-degree, number of nodes of such out-degree)

Definition at line 212 of file alg.h.

                                                           {
  TIntH DegToCntH;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    DegToCntH.AddDat(NI.GetOutDeg())++; }
  DegToCntV.Gen(DegToCntH.Len(), 0);
  for (int i = 0; i < DegToCntH.Len(); i++) {
    DegToCntV.Add(TFltPr(DegToCntH.GetKey(i).Val, DegToCntH[i].Val)); }
  DegToCntV.Sort();
}

PNEANet TSnap::GetOutEgonetAttr	(	const PNEANet &	Graph,
		const int	CtrNId,
		const int	Radius
	)

Returns the out-egonet of at given radius and copies node and edge attributes.

Definition at line 397 of file subgraph.cpp.

                                                                                   {
  PNEANet NewGraphPt = PNEANet::New();
  TNEANet &NewGraph = *NewGraphPt;
  TSnapQueue<int> Queue1;
  TSnapQueue<int> Queue2;
  TSnapQueue<int> tempSwapQueue;
  AddNodeWithAttributes(Graph, NewGraphPt, CtrNId);
  Queue1.Clr(false);
  Queue1.Push(CtrNId);
  for (int r = 0; r < Radius; ++r) {
    while (!Queue1.Empty()) {
      const int NId = Queue1.Top();
      Queue1.Pop();
      const TNEANet::TNodeI &Node = Graph->GetNI(NId);
      for (int i = 0; i < Node.GetOutDeg(); ++i) {
        const int OutNId = Node.GetOutNId(i);
        if (!NewGraph.IsNode(OutNId)) {
          AddNodeWithAttributes(Graph, NewGraphPt, OutNId);
          Queue2.Push(OutNId);
        }
        const int OutEId = Node.GetOutEId(i);
        if (!NewGraph.IsEdge(OutEId)) {
          AddEdgeWithAttributes(Graph, NewGraphPt, OutEId);
        }
      }
      for (int i = 0; i < Node.GetOutDeg(); ++i) {
        int OutNId = Node.GetOutNId(i);
        const TNEANet::TNodeI &OutNode = Graph->GetNI(OutNId);
        for (int j = 0; j < OutNode.GetInDeg(); ++j) {
          int NbrInNId = OutNode.GetInNId(j);
          if (NewGraph.IsNode(NbrInNId)) {
            const int InEId = OutNode.GetInEId(j);
            if (!NewGraph.IsEdge(InEId)) {
              AddEdgeWithAttributes(Graph, NewGraphPt, InEId);
            }
          }
        }
        for (int j = 0; j < OutNode.GetOutDeg(); ++j) {
          int NbrOutNId = OutNode.GetOutNId(j);
          if (NewGraph.IsNode(NbrOutNId)) {
            const int OutEId = OutNode.GetOutEId(j);
            if (!NewGraph.IsEdge(OutEId)) {
              AddEdgeWithAttributes(Graph, NewGraphPt, OutEId);
            }
          }
        }
      }
    }
    tempSwapQueue = Queue1;
    Queue1 = Queue2;
    Queue2 = tempSwapQueue;
  }
  return NewGraphPt;
}

template<class PGraph >

PGraph TSnap::GetOutEgonetHop	(	const PGraph &	Graph,
		const int	CtrNId,
		const int	Radius
	)

Returns the out-egonet of node CtrNId as center in directed graph Graph for a given radius.

Definition at line 642 of file subgraph.h.

                                                                                {
  PGraph NewGraphPt = PGraph::TObj::New();
  typename PGraph::TObj& NewGraph = *NewGraphPt;
  TSnapQueue<int> Queue1;
  TSnapQueue<int> Queue2;
  TSnapQueue<int> tempSwapQueue;
  NewGraph.AddNode(CtrNId);
  Queue1.Clr(false);
  Queue1.Push(CtrNId);
  for (int r = 0; r < Radius; ++r) {
    while (!Queue1.Empty()) {
      const int NId = Queue1.Top();
      Queue1.Pop();
      const typename PGraph::TObj::TNodeI &Node = Graph->GetNI(NId);
      for (int i = 0; i < Node.GetOutDeg(); ++i) {
        const int OutNId = Node.GetOutNId(i);
        if (!NewGraph.IsNode(OutNId)) {
          NewGraph.AddNode(OutNId);
          Queue2.Push(OutNId);
        }
        if (!NewGraph.IsEdge(NId, OutNId)) {
          NewGraph.AddEdge(NId, OutNId);
        }
      }
      for (int i = 0; i < Node.GetOutDeg(); ++i) {
        int OutNId = Node.GetOutNId(i);
        const typename PGraph::TObj::TNodeI &OutNode = Graph->GetNI(OutNId);
        for (int j = 0; j < OutNode.GetInDeg(); ++j) {
          int NbrInNId = OutNode.GetInNId(j);
          if (NewGraph.IsNode(NbrInNId)) {
            if (!NewGraph.IsEdge(NbrInNId, OutNId)) {
              NewGraph.AddEdge(NbrInNId, OutNId);
            }
          }
        }
        for (int j = 0; j < OutNode.GetOutDeg(); ++j) {
          int NbrOutNId = OutNode.GetOutNId(j);
          if (NewGraph.IsNode(NbrOutNId)) {
            if (!NewGraph.IsEdge(OutNId, NbrOutNId)) {
              NewGraph.AddEdge(OutNId, NbrOutNId);
            }
          }
        }
      }
    }
    tempSwapQueue = Queue1;
    Queue1 = Queue2;
    Queue2 = tempSwapQueue;
  }
  return NewGraphPt;
}

template<class PGraph >

void TSnap::GetPageRank	(	const PGraph &	Graph,
		TIntFltH &	PRankH,
		const double &	C = 0.85,
		const double &	Eps = 1e-4,
		const int &	MaxIter = 100
	)

PageRank For more info see: http://en.wikipedia.org/wiki/PageRank

Definition at line 240 of file centr.h.

                                                                                                                {
  const int NNodes = Graph->GetNodes();
  TVec<typename PGraph::TObj::TNodeI> NV;
  PRankH.Gen(NNodes);
  int MxId = -1;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    NV.Add(NI);
    PRankH.AddDat(NI.GetId(), 1.0/NNodes);
    int Id = NI.GetId();
    if (Id > MxId) {
      MxId = Id;
    }
  }

  TFltV PRankV(MxId+1);
  TIntV OutDegV(MxId+1);

  for (int j = 0; j < NNodes; j++) {
    typename PGraph::TObj::TNodeI NI = NV[j];
    int Id = NI.GetId();
    PRankV[Id] = 1.0/NNodes;
    OutDegV[Id] = NI.GetOutDeg();
  }

  TFltV TmpV(NNodes);

  for (int iter = 0; iter < MaxIter; iter++) {
    for (int j = 0; j < NNodes; j++) {
      typename PGraph::TObj::TNodeI NI = NV[j];
      TFlt Tmp = 0;
      for (int e = 0; e < NI.GetInDeg(); e++) {
        const int InNId = NI.GetInNId(e);
        const int OutDeg = OutDegV[InNId];
        if (OutDeg > 0) {
          Tmp += PRankV[InNId] / OutDeg;
        }
      }
      TmpV[j] =  C*Tmp; // Berkhin (the correct way of doing it)
    }
    double sum = 0;
    for (int i = 0; i < TmpV.Len(); i++) { sum += TmpV[i]; }
    const double Leaked = (1.0-sum) / double(NNodes);

    double diff = 0;
    for (int i = 0; i < NNodes; i++) {
      typename PGraph::TObj::TNodeI NI = NV[i];
      double NewVal = TmpV[i] + Leaked; // Berkhin
      int Id = NI.GetId();
      diff += fabs(NewVal-PRankV[Id]);
      PRankV[Id] = NewVal;
    }
    if (diff < Eps) { break; }
  }

  for (int i = 0; i < NNodes; i++) {
    typename PGraph::TObj::TNodeI NI = NV[i];
    PRankH[i] = PRankV[NI.GetId()];
  }
}

template<class PGraph >

void TSnap::GetPageRank_v1	(	const PGraph &	Graph,
		TIntFltH &	PRankH,
		const double &	C = 0.85,
		const double &	Eps = 1e-4,
		const int &	MaxIter = 100
	)

Definition at line 200 of file centr.h.

                                                                                                                   {
  const int NNodes = Graph->GetNodes();
  //const double OneOver = 1.0/double(NNodes);
  PRankH.Gen(NNodes);
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    PRankH.AddDat(NI.GetId(), 1.0/NNodes);
    //IAssert(NI.GetId() == PRankH.GetKey(PRankH.Len()-1));
  }
  TFltV TmpV(NNodes);
  for (int iter = 0; iter < MaxIter; iter++) {
    int j = 0;
    for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++, j++) {
      TmpV[j] = 0;
      for (int e = 0; e < NI.GetInDeg(); e++) {
        const int InNId = NI.GetInNId(e);
        const int OutDeg = Graph->GetNI(InNId).GetOutDeg();
        if (OutDeg > 0) {
          TmpV[j] += PRankH.GetDat(InNId) / OutDeg; }
      }
      TmpV[j] =  C*TmpV[j]; // Berkhin (the correct way of doing it)
      //TmpV[j] =  C*TmpV[j] + (1.0-C)*OneOver; // iGraph
    }
    double diff=0, sum=0, NewVal;
    for (int i = 0; i < TmpV.Len(); i++) { sum += TmpV[i]; }
    const double Leaked = (1.0-sum) / double(NNodes);
    for (int i = 0; i < PRankH.Len(); i++) { // re-instert leaked PageRank
      NewVal = TmpV[i] + Leaked; // Berkhin
      //NewVal = TmpV[i] / sum;  // iGraph
      diff += fabs(NewVal-PRankH[i]);
      PRankH[i] = NewVal;
    }
    if (diff < Eps) { break; }
  }
}

template<class PGraph >

void TSnap::GetPageRankMP	(	const PGraph &	Graph,
		TIntFltH &	PRankH,
		const double &	C = 0.85,
		const double &	Eps = 1e-4,
		const int &	MaxIter = 100
	)

Definition at line 306 of file centr.h.

                                                                                                                  {
  const int NNodes = Graph->GetNodes();
  TVec<typename PGraph::TObj::TNodeI> NV;
  PRankH.Gen(NNodes);

  int MxId = -1;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    NV.Add(NI);
    PRankH.AddDat(NI.GetId(), 1.0/NNodes);
    int Id = NI.GetId();
    if (Id > MxId) {
      MxId = Id;
    }
  }

  TFltV PRankV(MxId+1);
  TIntV OutDegV(MxId+1);

  #pragma omp parallel for schedule(dynamic,10000)
  for (int j = 0; j < NNodes; j++) {
    typename PGraph::TObj::TNodeI NI = NV[j];
    int Id = NI.GetId();
    PRankV[Id] = 1.0/NNodes;
    OutDegV[Id] = NI.GetOutDeg();
  }

  TFltV TmpV(NNodes);
  for (int iter = 0; iter < MaxIter; iter++) {
    #pragma omp parallel for schedule(dynamic,10000)
    for (int j = 0; j < NNodes; j++) {
      typename PGraph::TObj::TNodeI NI = NV[j];
      TFlt Tmp = 0;
      for (int e = 0; e < NI.GetInDeg(); e++) {
        const int InNId = NI.GetInNId(e);
        const int OutDeg = OutDegV[InNId];
        if (OutDeg > 0) {
          Tmp += PRankV[InNId] / OutDeg;
        }
      }
      TmpV[j] =  C*Tmp; // Berkhin (the correct way of doing it)
    }

    double sum = 0;
    #pragma omp parallel for reduction(+:sum) schedule(dynamic,10000)
    for (int i = 0; i < TmpV.Len(); i++) { sum += TmpV[i]; }
    const double Leaked = (1.0-sum) / double(NNodes);

    double diff = 0;
    #pragma omp parallel for reduction(+:diff) schedule(dynamic,10000)
    for (int i = 0; i < NNodes; i++) {
      double NewVal = TmpV[i] + Leaked; // Berkhin
      int Id = NV[i].GetId();
      diff += fabs(NewVal-PRankV[Id]);
      PRankV[Id] = NewVal;
    }
    if (diff < Eps) { break; }
  }

  #pragma omp parallel for schedule(dynamic,10000)
  for (int i = 0; i < NNodes; i++) {
    typename PGraph::TObj::TNodeI NI = NV[i];
    PRankH[i] = PRankV[NI.GetId()];
  }
}

template<class PGraph >

double TSnap::GetPersonalizedPageRankBidirectional	(	const PGraph &	Graph,
		double	JumpProb,
		const TIntV &	StartNIdV,
		int	TargetNId,
		double	MinProbability = -1.0,
		double	RelativeError = 0.1,
		bool	provableRelativeError = false,
		bool	PrintTimeForTuning = false
	)

Definition at line 88 of file randwalk.h.

                                                                               {
  if (MinProbability <= 0.0) { // Check if minProbability not set.
    MinProbability = 1.0 / Graph->GetNodes();
  }
  // In experiments, when relativeError = 0.1, a chernoff constant of 0.07 gave mean relative error less than 0.1 on several realistic graphs.
  float kChernoffConstant = provableRelativeError ? 12 * exp((double) 1) * log(2 / 1.0e-9) : 0.07;
  float kSecondsPerWalk = 4.0e-7; // The time required to generate a random walk. Can be tuned so that forward and reverse running times are equal, to improve running time
  float WalkCountRMaxRatio = kChernoffConstant / (RelativeError * RelativeError) / MinProbability;
  float ForwardSecondsRMaxRatio = kSecondsPerWalk * WalkCountRMaxRatio;
  
  
  double startTime = WallClockTime();
  // Results from ApproxContributionsBalanced are set by reference:
  TIntFltH Estimates, Residuals;
  float MaxResidual;
  ApproxContributionsBalanced(Graph, JumpProb, TargetNId, ForwardSecondsRMaxRatio, Estimates, Residuals, MaxResidual);
  
  double reverseTime = WallClockTime() - startTime;
  startTime = WallClockTime();
  
  double Estimate = 0.0;
  // First incorporate the average Estimates value for starting nodes
  for (int i = 0; i < StartNIdV.Len(); i++) {
    Estimate += Estimates.GetDatWithDefault(StartNIdV[i], 0.0) / StartNIdV.Len();
  }
  
  int RandomWalkCount = static_cast<int>(WalkCountRMaxRatio * MaxResidual);
  TRnd Rnd(0); // 0 means seed from clock. We use an explicit Rnd for thread safety.
  for (int i = 0; i < RandomWalkCount; i++) {
    int vId = SamplePersonalizedPageRank(Graph, JumpProb, StartNIdV, Rnd);
    Estimate += Residuals.GetDatWithDefault(vId, 0.0) / RandomWalkCount;
  }
  double forwardTime = WallClockTime() - startTime;
  if (PrintTimeForTuning) printf("forwardTime reverseTime %g %g\n", forwardTime, reverseTime);
  
  return Estimate;
}

template<class PGraph >

PGraph TSnap::GetRndESubGraph	(	const PGraph &	Graph,
		const int &	NEdges
	)

Returns a random subgraph of graph Graph with NEdges edges.

Randomly selects NEdges edges from the input graph and returns a subgraph on those edges.

Definition at line 490 of file subgraph.h.

                                                               {
  CAssert(! HasGraphFlag(typename PGraph::TObj, gfMultiGraph));
  TIntPrV EdgeV(Graph->GetEdges(), 0);
  for (typename PGraph::TObj::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
    EdgeV.Add(TIntPr(EI.GetSrcNId(), EI.GetDstNId()));
  }
  EdgeV.Shuffle(TInt::Rnd);
  EdgeV.Del(NEdges, EdgeV.Len()-1);
  IAssert(EdgeV.Len() == NEdges);
  return GetESubGraph(Graph, EdgeV);
}

template<class PGraph >

PGraph TSnap::GetRndSubGraph	(	const PGraph &	Graph,
		const int &	NNodes
	)

Returns an induced random subgraph of graph Graph with NNodes nodes.

Randomly selects NNodes nodes from the input graph and returns an induced graph on those nodes.

Definition at line 479 of file subgraph.h.

                                                              {
  IAssert(NNodes <= Graph->GetNodes());
  TIntV NIdV;
  Graph->GetNIdV(NIdV);
  NIdV.Shuffle(TInt::Rnd);
  NIdV.Del(NNodes, NIdV.Len()-1);
  IAssert(NIdV.Len() == NNodes);
  return GetSubGraph(Graph, NIdV);
}

template<class PGraph >

double TSnap::GetRndWalkRestartBidirectional	(	const PGraph &	Graph,
		double	JumpProb,
		int	StartNId,
		int	TargetNId,
		double	minProbability = -1.0,
		double	relativeError = 0.1,
		bool	proveRelativeError = false,
		bool	PrintTimeForTuning = false
	)

Definition at line 135 of file randwalk.h.

                                                                         {
    return GetPersonalizedPageRankBidirectional(Graph, JumpProb, TIntV::GetV(StartNId), TargetNId,
                                                minProbability, relativeError, proveRelativeError, PrintTimeForTuning);
  }

template<class PGraph >

void TSnap::GetSccs	(	const PGraph &	Graph,
		TCnComV &	CnComV
	)

Returns all strongly connected components in a Graph.

Parameters

CnComV

is a vector of connected components. Each component is defined by the IDs of its member nodes.

Definition at line 428 of file cncom.h.

                                                   {
  TSccVisitor<PGraph, false> Visitor(Graph);
  TCnCom::GetDfsVisitor(Graph, Visitor);
  CnComV = Visitor.CnComV;
  CnComV.Sort(false);
}

template<class PGraph >

void TSnap::GetSccSzCnt	(	const PGraph &	Graph,
		TIntPrV &	SccSzCnt
	)

Returns a distribution of strongly connected component sizes.

Parameters

SccSzCnt

returns a set of pairs (number of nodes in the component, number of such components)

Definition at line 420 of file cncom.h.

                                                         {
  TSccVisitor<PGraph, true> Visitor(Graph);
  TCnCom::GetDfsVisitor(Graph, Visitor);
  Visitor.SccCntH.GetKeyDatPrV(SccSzCnt);
  SccSzCnt.Sort(true);
}

template<class PGraph >

int TSnap::GetShortestDistances	(	const PGraph &	Graph,
		const int &	StartNId,
		const bool &	FollowOut,
		const bool &	FollowIn,
		TIntV &	ShortestDists
	)

Definition at line 501 of file bfsdfs.h.

                                                                                                                                      {
  PSOut StdOut = TStdOut::New();
  int MxNId = Graph->GetMxNId();
  int NonNodeDepth = 2147483647; // INT_MAX
  int InfDepth = 2147483646; // INT_MAX - 1
  ShortestDists.Gen(MxNId);
  for (int NId = 0; NId < MxNId; NId++) {
    if (Graph->IsNode(NId)) { ShortestDists[NId] = InfDepth; }
    else { ShortestDists[NId] = NonNodeDepth; }
  }

  TIntV Vec1(MxNId, 0); // ensure enough capacity
  TIntV Vec2(MxNId, 0); // ensure enough capacity

  ShortestDists[StartNId] = 0;
  TIntV* PCurV = &Vec1;
  PCurV->Add(StartNId);
  TIntV* PNextV = &Vec2;
  int Depth = 0; // current depth
  while (!PCurV->Empty()) {
    Depth++; // increase depth
    for (int i = 0; i < PCurV->Len(); i++) {
      int NId = PCurV->GetVal(i);
      typename PGraph::TObj::TNodeI NI = Graph->GetNI(NId);
      for (int e = 0; e < NI.GetOutDeg(); e++) {
        const int OutNId = NI.GetOutNId(e);
        if (ShortestDists[OutNId].Val == InfDepth) {
          ShortestDists[OutNId] = Depth;
          PNextV->Add(OutNId);
        }
      }
    }
    // swap pointer, no copying
    TIntV* Tmp = PCurV;
    PCurV = PNextV;
    PNextV = Tmp;
    // clear next
    PNextV->Reduce(0); // reduce length, does not initialize new array
  }
  return Depth-1;
}

template<class PGraph >

int TSnap::GetShortestDistancesMP2	(	const PGraph &	Graph,
		const int &	StartNId,
		const bool &	FollowOut,
		const bool &	FollowIn,
		TIntV &	ShortestDists
	)

Definition at line 545 of file bfsdfs.h.

                                                                                                                                         {
  int MxNId = Graph->GetMxNId();
  int NonNodeDepth = 2147483647; // INT_MAX
  int InfDepth = 2147483646; // INT_MAX - 1
  ShortestDists.Gen(MxNId);
  #pragma omp parallel for schedule(dynamic,10000)
  for (int NId = 0; NId < MxNId; NId++) {
    if (Graph->IsNode(NId)) { ShortestDists[NId] = InfDepth; }
    else { ShortestDists[NId] = NonNodeDepth; }
  }

  TIntV Vec1(MxNId, 0); // ensure enough capacity
  TIntV Vec2(MxNId, 0); // ensure enough capacity

  ShortestDists[StartNId] = 0;
  TIntV* PCurV = &Vec1;
  PCurV->Add(StartNId);
  TIntV* PNextV = &Vec2;
  int Depth = 0; // current depth

  while (!PCurV->Empty()) {
    Depth++; // increase depth
    #pragma omp parallel for schedule(dynamic,10000)
    for (int i = 0; i < PCurV->Len(); i++) {
      int NId = PCurV->GetVal(i);
      typename PGraph::TObj::TNodeI NI = Graph->GetNI(NId);
      for (int e = 0; e < NI.GetOutDeg(); e++) {
        const int OutNId = NI.GetOutNId(e);
        if (__sync_bool_compare_and_swap(&(ShortestDists[OutNId].Val), InfDepth, Depth)) {
          PNextV->AddMP(OutNId);
        }
      }
    }
//      #pragma omp parallel for schedule(dynamic,10000)
//      for (int NId = 0; NId < MxNId; NId++) {
//        if (ShortestDists[NId] == InfDepth) {
//          typename PGraph::TObj::TNodeI NI = Graph->GetNI(NId);
//          for (int e = 0; e < NI.GetInDeg(); e++) {
//            const int InNId = NI.GetInNId(e);
//            if (ShortestDists[InNId] < Depth) {
//              ShortestDists[NId] = Depth;
//              PNextV->AddMP(NId);
//              break;
//            }
//          }
//        }
//      }
    // swap pointer, no copying
    TIntV* Tmp = PCurV;
    PCurV = PNextV;
    PNextV = Tmp;
    // clear next
    PNextV->Reduce(0); // reduce length, does not initialize new array
  }
  return Depth-1;
}

template<class PGraph >

int TSnap::GetShortPath	(	const PGraph &	Graph,
		const int &	SrcNId,
		const int &	DstNId,
		const bool &	IsDir = false
	)

Returns the length of the shortest path from node SrcNId to node DstNId.

Parameters

IsDir

false: ignore edge directions and consider edges/paths as undirected (in case they are directed).

Definition at line 409 of file bfsdfs.h.

                                                                                               {
  TBreathFS<PGraph> BFS(Graph);
  BFS.DoBfs(SrcNId, true, ! IsDir, DstNId, TInt::Mx);
  return BFS.GetHops(SrcNId, DstNId);
}

template<class PGraph >

int TSnap::GetShortPath	(	const PGraph &	Graph,
		const int &	SrcNId,
		TIntH &	NIdToDistH,
		const bool &	IsDir = false,
		const int &	MaxDist = TInt::Mx
	)

Returns the length of the shortest path from node SrcNId to all other nodes in the network.

Parameters

IsDir	false: ignore edge directions and consider edges/paths as undirected (in case they are directed).
MaxDist	Maximum number of hops that BFS expands to. This is helpful for speeding-up the code if one in interested only in nodes less than MaxDist away from SrcNId.
NIdToDistH	Maps node ID to shortest path distance. NIdToDistH contains only nodes that are reachable from SrcNId.

Definition at line 400 of file bfsdfs.h.

                                                                                                                   {
  TBreathFS<PGraph> BFS(Graph);
  BFS.DoBfs(SrcNId, true, ! IsDir, -1, MaxDist);
  NIdToDistH.Clr();
  NIdToDistH.Swap(BFS.NIdDistH);
  return NIdToDistH[NIdToDistH.Len()-1];
}

void TSnap::GetSngVals	(	const PNGraph &	Graph,
		const int &	SngVals,
		TFltV &	SngValV
	)

Computes largest SngVals singular values of the adjacency matrix representing a directed Graph.

Definition at line 175 of file gsvd.cpp.

                                                                          {
  const int Nodes = Graph->GetNodes();
  IAssert(SngVals > 0);
  if (Nodes < 100) {
    // perform full SVD
    TFltVV AdjMtx(Nodes+1, Nodes+1);
    TFltVV LSingV, RSingV;
    TIntH NodeIdH;
    // create adjecency matrix
    for (TNGraph::TNodeI NodeI = Graph->BegNI(); NodeI < Graph->EndNI(); NodeI++) {
      NodeIdH.AddKey(NodeI.GetId()); }
    for (TNGraph::TNodeI NodeI = Graph->BegNI(); NodeI < Graph->EndNI(); NodeI++) {
      const int NodeId = NodeIdH.GetKeyId(NodeI.GetId()) + 1;
      for (int e = 0; e < NodeI.GetOutDeg(); e++) {
        const int DstNId = NodeIdH.GetKeyId(NodeI.GetOutNId(e)) + 1;  // no self edges
        if (NodeId != DstNId) AdjMtx.At(NodeId, DstNId) = 1;
      }
    }
    try { // can fail to converge but results seem to be good
      TSvd::Svd1Based(AdjMtx, LSingV, SngValV, RSingV); }
    catch(...) {
      printf("\n***No SVD convergence: G(%d, %d)\n", Nodes, Graph->GetEdges()); }
  } else {
    // Lanczos
    TNGraphMtx GraphMtx(Graph);
    int CalcVals = int(2*SngVals);
    //if (CalcVals > Nodes) { CalcVals = int(2*Nodes); }
    //if (CalcVals > Nodes) { CalcVals = Nodes; }
    //while (SngValV.Len() < SngVals && CalcVals < 10*SngVals) {
    try {
      if (SngVals > 4) { 
        TSparseSVD::SimpleLanczosSVD(GraphMtx, 2*SngVals, SngValV, false); }
      else { TFltVV LSingV, RSingV;  // this is much more precise, but also much slower
        TSparseSVD::LanczosSVD(GraphMtx, SngVals, 3*SngVals, ssotFull, SngValV, LSingV, RSingV); }
    }
    catch(...) {
      printf("\n  ***EXCEPTION:  TRIED %d GOT %d values** \n", 2*SngVals, SngValV.Len()); }
    if (SngValV.Len() < SngVals) {
      printf("  ***TRIED %d GOT %d values** \n", CalcVals, SngValV.Len()); }
    //  CalcVals += SngVals;
    //}
  }
  SngValV.Sort(false);
  //if (SngValV.Len() > SngVals) {
  //  SngValV.Del(SngVals, SngValV.Len()-1); }
  //else {
  //  while (SngValV.Len() < SngVals) SngValV.Add(1e-6); }
  //IAssert(SngValV.Len() == SngVals);
}

void TSnap::GetSngVec	(	const PNGraph &	Graph,
		TFltV &	LeftSV,
		TFltV &	RightSV
	)

Computes the leading left and right singular vector of the adjacency matrix representing a directed Graph.

Definition at line 225 of file gsvd.cpp.

                                                                    {
  const int Nodes = Graph->GetNodes();
  TFltVV LSingV, RSingV;
  TFltV SngValV;
  if (Nodes < 500) {
    // perform full SVD
    TFltVV AdjMtx(Nodes+1, Nodes+1);
    TIntH NodeIdH;
    // create adjecency matrix
    for (TNGraph::TNodeI NodeI = Graph->BegNI(); NodeI < Graph->EndNI(); NodeI++) {
      NodeIdH.AddKey(NodeI.GetId()); }
    for (TNGraph::TNodeI NodeI = Graph->BegNI(); NodeI < Graph->EndNI(); NodeI++) {
      const int NodeId = NodeIdH.GetKeyId(NodeI.GetId()) + 1;
      for (int e = 0; e < NodeI.GetOutDeg(); e++) {
        const int DstNId = NodeIdH.GetKeyId(NodeI.GetOutNId(e)) + 1;  // no self edges
        if (NodeId != DstNId) AdjMtx.At(NodeId, DstNId) = 1;
      }
    }
    try { // can fail to converge but results seem to be good
      TSvd::Svd1Based(AdjMtx, LSingV, SngValV, RSingV); }
    catch(...) {
      printf("\n***No SVD convergence: G(%d, %d)\n", Nodes, Graph->GetEdges()); }
  } else { // Lanczos
    TNGraphMtx GraphMtx(Graph);
    TSparseSVD::LanczosSVD(GraphMtx, 1, 8, ssotFull, SngValV, LSingV, RSingV);
  }
  TFlt MxSngVal = TFlt::Mn;
  int ValN = 0;
  for (int i = 0; i < SngValV.Len(); i++) {
    if (MxSngVal < SngValV[i]) { MxSngVal = SngValV[i]; ValN = i; } }
  LSingV.GetCol(ValN, LeftSV);
  RSingV.GetCol(ValN, RightSV);
  IsAllValVNeg(LeftSV, true);
  IsAllValVNeg(RightSV, true);
}

void TSnap::GetSngVec	(	const PNGraph &	Graph,
		const int &	SngVecs,
		TFltV &	SngValV,
		TFltVFltV &	LeftSV,
		TFltVFltV &	RightSV
	)

Computes the singular values and left and right singular vectors of the adjacency matrix representing a directed Graph.

Parameters

SngVecs

Number of singular values/vectors to compute.

Definition at line 261 of file gsvd.cpp.

                                                                                                                {
  const int Nodes = Graph->GetNodes();
  SngValV.Clr();
  LeftSV.Clr();
  RightSV.Clr();
  TFltVV LSingV, RSingV;
  if (Nodes < 100) {
    // perform full SVD
    TFltVV AdjMtx(Nodes+1, Nodes+1);
    TIntH NodeIdH;
    // create adjecency matrix (1-based)
    for (TNGraph::TNodeI NodeI = Graph->BegNI(); NodeI < Graph->EndNI(); NodeI++) {
      NodeIdH.AddKey(NodeI.GetId()); }
    for (TNGraph::TNodeI NodeI = Graph->BegNI(); NodeI < Graph->EndNI(); NodeI++) {
      const int NodeId = NodeIdH.GetKeyId(NodeI.GetId())+1;
      for (int e = 0; e < NodeI.GetOutDeg(); e++) {
        const int DstNId = NodeIdH.GetKeyId(NodeI.GetOutNId(e))+1;  // no self edges
        if (NodeId != DstNId) AdjMtx.At(NodeId, DstNId) = 1;
      }
    }
    try { // can fail to converge but results seem to be good
      TSvd::Svd1Based(AdjMtx, LSingV, SngValV, RSingV);
    } catch(...) {
      printf("\n***No SVD convergence: G(%d, %d)\n", Nodes, Graph->GetEdges()); 
    }
  } else { // Lanczos
    TNGraphMtx GraphMtx(Graph);
    TSparseSVD::LanczosSVD(GraphMtx, SngVecs, 2*SngVecs, ssotFull, SngValV, LSingV, RSingV);
    //TGAlg::SaveFullMtx(Graph, "adj_mtx.txt");
    //TLAMisc::DumpTFltVVMjrSubMtrx(LSingV, LSingV.GetRows(), LSingV.GetCols(), "LSingV2.txt"); // save MTX
  }
  TFltIntPrV SngValIdV;
  for (int i = 0; i < SngValV.Len(); i++) {
    SngValIdV.Add(TFltIntPr(SngValV[i], i)); 
  }
  SngValIdV.Sort(false);
  SngValV.Sort(false);
  for (int v = 0; v < SngValIdV.Len(); v++) { 
    LeftSV.Add();
    LSingV.GetCol(SngValIdV[v].Val2, LeftSV.Last());
    RightSV.Add();
    RSingV.GetCol(SngValIdV[v].Val2, RightSV.Last());
  }
  IsAllValVNeg(LeftSV[0], true);
  IsAllValVNeg(RightSV[0], true);
}

PUNGraph TSnap::GetSubGraph	(	const PUNGraph &	Graph,
		const TIntV &	NIdV,
		const bool &	RenumberNodes = false
	)

Returns an induced subgraph of an undirected graph Graph with NIdV nodes with an optional node renumbering.

The resulting subgraph contains all the nodes from Graph, which have node IDs in the NIdV vector and all the edges with both nodes in NIdV. Parameter RenumberNodes determines, whether the node IDs are preserved or not. If RenumberNodes is false, then nodes in the resulting subgraph have the same node IDs as nodes in Graph. If RenumberNodes is true, then nodes in the resulting subgraph are renumbered sequentially from 0 to N-1. By default, the nodes are not renumbered.

Definition at line 7 of file subgraph.cpp.

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

template<class PGraph >

PGraph TSnap::GetSubGraph	(	const PGraph &	Graph,
		const TIntV &	NIdV
	)

Returns an induced subgraph of graph Graph with NIdV nodes.

The resulting subgraph contains all the nodes from Graph, which have node IDs in the NIdV vector and all the edges with both nodes in NIdV. Node IDs are preserved. Nodes in the resulting subgraph have the same node IDs as nodes in Graph.

Definition at line 232 of file subgraph.h.

                                                           {
  return TSnapDetail::TGetSubGraph<PGraph, HasGraphFlag(typename PGraph::TObj, gfMultiGraph)>
    ::Do(Graph, NIdV);
}

PNGraph TSnap::GetSubGraph	(	const PNGraph &	Graph,
		const TIntV &	NIdV,
		const bool &	RenumberNodes
	)

Definition at line 45 of file subgraph.cpp.

                                                                                        {
  //if (! RenumberNodes) { return TSnap::GetSubGraph(Graph, NIdV); }
  PNGraph NewGraphPt = TNGraph::New();
  TNGraph& 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 TNGraph::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 TNGraph::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;
}

template<class PGraph >

PGraph TSnap::GetSubGraphRenumber	(	const PGraph &	Graph,
		const TIntV &	NIdV
	)

Returns an induced subgraph of graph Graph with NIdV nodes with an node renumbering.

The resulting subgraph contains all the nodes from Graph, which have node IDs in the NIdV vector and all the edges with both nodes in NIdV. Node IDs are preserved. Nodes in the resulting subgraph have the same node IDs as nodes in Graph.

Definition at line 238 of file subgraph.h.

                                                                   {
  return GetSubGraph(Graph, NIdV, true);
}

template<class PGraph >

int TSnap::GetSubTreeSz	(	const PGraph &	Graph,
		const int &	StartNId,
		const bool &	FollowOut,
		const bool &	FollowIn,
		int &	TreeSzX,
		int &	TreeDepthX
	)

Returns the BFS tree size (number of nodes) and depth (number of levels) by following in-links (parameter FollowIn = true) and/or out-links (parameter FollowOut = true) of node StartNId.

Definition at line 363 of file bfsdfs.h.

                                                                                                                                     {
  TBreathFS<PGraph> BFS(Graph);
  BFS.DoBfs(StartNId, FollowOut, FollowIn, -1, TInt::Mx);
  TreeSz = BFS.NIdDistH.Len();
  TreeDepth = 0;
  for (int i = 0; i < BFS.NIdDistH.Len(); i++) {
    TreeDepth = TMath::Mx(TreeDepth, BFS.NIdDistH[i].Val);
  }
  return TreeSz;
}

template<class PGraph >

int TSnap::GetTreeRootNId

(

const PGraph &

Graph

)

Definition at line 80 of file alg.h.

{ int RootNId; bool Tree; Tree = IsTree(Graph, RootNId);  Assert(Tree);  return RootNId; }

template<class PGraph >

void TSnap::GetTreeSig	(	const PGraph &	Graph,
		const int &	RootNId,
		TIntV &	Sig
	)

Definition at line 484 of file alg.h.

                                                                     {
  CAssert(HasGraphFlag(typename PGraph::TObj, gfDirected));
  Sig.Gen(Graph->GetNodes(), 0);
  TSnapQueue<int> NIdQ(Graph->GetNodes());
  NIdQ.Push(RootNId);
  int LastPos = 0, NodeCnt = 1;
  while (! NIdQ.Empty()) {
    const typename PGraph::TObj::TNodeI Node = Graph->GetNI(NIdQ.Top());  NIdQ.Pop();
    IAssert(Node.GetInDeg()==0 || Node.GetOutDeg()==0); // child points or is-pointed to by the parent
    if (Node.GetInDeg() != 0) {
      for (int e = 0; e < Node.GetInDeg(); e++) {
        NIdQ.Push(Node.GetInNId(e)); }
    } else if (Node.GetOutDeg() != 0) {
      for (int e = 0; e < Node.GetOutDeg(); e++) {
        NIdQ.Push(Node.GetOutNId(e)); }
    }
    Sig.Add(Node.GetInDeg());
    if (--NodeCnt == 0) {
      for (int i = LastPos; i < Sig.Len(); i++) NodeCnt += Sig[i];
      Sig.QSort(LastPos, Sig.Len()-1, false);
      LastPos = Sig.Len();
    }
  }
}

template<class PGraph >

void TSnap::GetTreeSig	(	const PGraph &	Graph,
		const int &	RootNId,
		TIntV &	Sig,
		TIntPrV &	NodeMap
	)

Definition at line 511 of file alg.h.

                                                                                       {
  CAssert(HasGraphFlag(typename PGraph::TObj, gfDirected));
  NodeMap.Gen(Graph->GetNodes(), 0);
  Sig.Gen(Graph->GetNodes(), 0);
  TSnapQueue<int> NIdQ(Graph->GetNodes());
  NIdQ.Push(RootNId);
  int LastPos = 0, NodeCnt = 1;
  while (! NIdQ.Empty()) {
    const typename PGraph::TObj::TNodeI Node = Graph->GetNI(NIdQ.Top());  NIdQ.Pop();
    IAssert(Node.GetInDeg()==0 || Node.GetOutDeg()==0); // child points or is-pointed to by the parent
    if (Node.GetInDeg() != 0) {
      for (int e = 0; e < Node.GetInDeg(); e++) {
        NIdQ.Push(Node.GetInNId(e)); }
      NodeMap.Add(TIntPr(Node.GetInDeg(), Node.GetId()));
    } else if (Node.GetOutDeg() != 0) {
      for (int e = 0; e < Node.GetOutDeg(); e++) {
        NIdQ.Push(Node.GetOutNId(e)); }
      NodeMap.Add(TIntPr(Node.GetOutDeg(), Node.GetId()));
    }
    if (--NodeCnt == 0) {
      for (int i = LastPos; i < NodeMap.Len(); i++) {
        NodeCnt += NodeMap[i].Val1; }
      NodeMap.QSort(LastPos, NodeMap.Len()-1, false);
      LastPos = NodeMap.Len();
    }
  }
  for (int i = 0; i < NodeMap.Len(); i++) {
    Sig.Add(NodeMap[i].Val1); // degree dignature
    NodeMap[i].Val1 = NodeMap[i].Val2;
    NodeMap[i].Val2 = i;
  }
}

template<class PGraph >

int TSnap::GetTriadEdges	(	const PGraph &	Graph,
		int	SampleEdges = -1
	)

Counts the number of edges that participate in at least one triad.

Considers the graph as undirected.

Parameters

SampleNodes

If !=-1 then compute triads only for a random sample of SampleNodes nodes. Useful for approximate but quick computations.

Definition at line 579 of file triad.h.

                                                        {
  const bool IsDir = Graph->HasFlag(gfDirected);
  TIntSet NbrH;
  int TriadEdges = 0;
  for(typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    NbrH.Clr(false);
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      if (NI.GetOutNId(e) != NI.GetId()) {
        NbrH.AddKey(NI.GetOutNId(e)); }
    }
    if (IsDir) {
      for (int e = 0; e < NI.GetInDeg(); e++) {
        if (NI.GetInNId(e) != NI.GetId()) {
          NbrH.AddKey(NI.GetInNId(e)); }
      }
    }
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      if (!IsDir && NI.GetId()<NI.GetOutNId(e)) { continue; } // for undirected graphs count each edge only once
      const typename PGraph::TObj::TNodeI SrcNode = Graph->GetNI(NI.GetOutNId(e));
      bool Triad=false;
      for (int e1 = 0; e1 < SrcNode.GetOutDeg(); e1++) {
        if (NbrH.IsKey(SrcNode.GetOutNId(e1))) { Triad=true; break; }
      }
      if (IsDir && ! Triad) {
        for (int e1 = 0; e1 < SrcNode.GetInDeg(); e1++) {
          if (NbrH.IsKey(SrcNode.GetInNId(e1))) { Triad=true; break; }
        }
      }
      if (Triad) { TriadEdges++; }
    }
  }
  return TriadEdges;
}

template<class PGraph >

void TSnap::GetTriadParticip	(	const PGraph &	Graph,
		TIntPrV &	TriadCntV
	)

Triangle Participation Ratio: For each node counts how many triangles it participates in and then returns a set of pairs (number of triangles, number of such nodes).

Considers the graph as undirected.

Definition at line 697 of file triad.h.

                                                               {
  TIntH TriadCntH;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    const int Triads = GetNodeTriads(Graph, NI.GetId());
    TriadCntH.AddDat(Triads) += 1;
  }
  TriadCntH.GetKeyDatPrV(TriadCntV);
  TriadCntV.Sort();
}

template<class PGraph >

int64 TSnap::GetTriads	(	const PGraph &	Graph,
		int	SampleNodes = -1
	)

Returns the number of triangles in a graph.

The function returns the number of unique triples of connected nodes (regardless of the number of edges between each pair of nodes). In other words, the function consideres the Graph as a simple undirected graph.

Parameters

SampleNodes

If !=-1 then compute triads only for a random sample of SampleNodes nodes. Useful for approximate but quick computations.

Definition at line 240 of file triad.h.

                                                      {
  int64 OpenTriads, ClosedTriads;
  return GetTriads(Graph, ClosedTriads, OpenTriads, SampleNodes);
}

template<class PGraph >

void TSnap::GetTriads	(	const PGraph &	Graph,
		TIntTrV &	NIdCOTriadV,
		int	SampleNodes = -1
	)

Computes the number of open and close triads for every node of the network.

Considers the graph as undirected.

Parameters

NIdCOTriadV	Triple (node id, open triads: number of pairs of node's neighbors that are not connected, closed triads: number of pairs of node's neighbors that are connected between themselves).
SampleNodes	If !=-1 then compute triads only for a random sample of SampleNodes nodes. Useful for approximate but quick computations.

Definition at line 318 of file triad.h.

                                                                           {
  const bool IsDir = Graph->HasFlag(gfDirected);
  TIntSet NbrH;
  TIntV NIdV;
  //TRnd Rnd(0);
  TRnd Rnd(1);
  int NNodes;
  TIntV Nbrs;
  int NId;

  int64 hcount;

  hcount = 0;

  NNodes = Graph->GetNodes();
  Graph->GetNIdV(NIdV);
  NIdV.Shuffle(Rnd);
  if (SampleNodes == -1) {
    SampleNodes = NNodes;
  }

  int MxId = -1;
  for (int i = 0; i < NNodes; i++) {
    if (NIdV[i] > MxId) {
      MxId = NIdV[i];
    }
  }

  TVec<TIntV> NbrV(MxId + 1);

  if (IsDir) {
    // get in and out neighbors
    for (int node = 0; node < NNodes; node++) {
      int NId = NIdV[node];
      NbrV[NId] = TIntV();
      GetUniqueNbrV(Graph, NId, NbrV[NId]);
    }
  } else {
    // get only out neighbors
    for (int node = 0; node < NNodes; node++) {
      int NId = NIdV[node];
      typename PGraph::TObj::TNodeI NI = Graph->GetNI(NId);
      NbrV[NId] = TIntV();
      NbrV[NId].Reserve(NI.GetOutDeg());
      NbrV[NId].Reduce(0);
      for (int i = 0; i < NI.GetOutDeg(); i++) {
        NbrV[NId].Add(NI.GetOutNId(i));
      }
    }
  }

  NIdCOTriadV.Clr(false);
  NIdCOTriadV.Reserve(SampleNodes);
  for (int node = 0; node < SampleNodes; node++) {
    typename PGraph::TObj::TNodeI NI = Graph->GetNI(NIdV[node]);
    int NLen;

    NId = NI.GetId();
    hcount++;
    if (NI.GetDeg() < 2) {
      NIdCOTriadV.Add(TIntTr(NId, 0, 0)); // zero triangles
      continue;
    }

    Nbrs = NbrV[NId];
    NLen = Nbrs.Len();

    // count connected neighbors
    int OpenCnt1 = 0, CloseCnt1 = 0;
    for (int srcNbr = 0; srcNbr < NLen; srcNbr++) {
      int Count = GetCommon(NbrV[NbrV[NId][srcNbr]],Nbrs);
      CloseCnt1 += Count;
    }
    CloseCnt1 /= 2;
    OpenCnt1 = (NLen*(NLen-1))/2 - CloseCnt1;
    NIdCOTriadV.Add(TIntTr(NId, CloseCnt1, OpenCnt1));
  }
}

template<class PGraph >

int64 TSnap::GetTriads	(	const PGraph &	Graph,
		int64 &	ClosedTriadsX,
		int64 &	OpenTriadsX,
		int	SampleNodes = -1
	)

Computes the number of Closed and Open triads.

Considers the graph as undirected.

Parameters

SampleNodes

If !=-1 then compute triads only for a random sample of SampleNodes nodes. Useful for approximate but quick computations.

Definition at line 246 of file triad.h.

                                                                                              {
  TIntTrV NIdCOTriadV;
  GetTriads(Graph, NIdCOTriadV, SampleNodes);
  uint64 closedTriads = 0;
  uint64 openTriads = 0;
  for (int i = 0; i < NIdCOTriadV.Len(); i++) {
    closedTriads += NIdCOTriadV[i].Val2;
    openTriads += NIdCOTriadV[i].Val3;
  }
  //IAssert(closedTriads/3 < (uint64) TInt::Mx);
  //IAssert(openTriads < (uint64) TInt::Mx);
  ClosedTriads = int64(closedTriads/3); // each triad is counted 3 times
  OpenTriads = int64(openTriads);
  return ClosedTriads;
}

template<class PGraph >

void TSnap::GetTriads_v0	(	const PGraph &	Graph,
		TIntTrV &	NIdCOTriadV,
		int	SampleNodes
	)

Definition at line 270 of file triad.h.

                                                                              {
  const bool IsDir = Graph->HasFlag(gfDirected);
  TIntSet NbrH;
  TIntV NIdV;
  TRnd Rnd(0);

  Graph->GetNIdV(NIdV);
  NIdV.Shuffle(Rnd);
  if (SampleNodes == -1) {
    SampleNodes = Graph->GetNodes(); }
  NIdCOTriadV.Clr(false);
  NIdCOTriadV.Reserve(SampleNodes);
  for (int node = 0; node < SampleNodes; node++) {
    typename PGraph::TObj::TNodeI NI = Graph->GetNI(NIdV[node]);
    if (NI.GetDeg() < 2) {
      NIdCOTriadV.Add(TIntTr(NI.GetId(), 0, 0)); // zero triangles
      continue;
    }
    // find neighborhood
    NbrH.Clr(false);
    for (int e = 0; e < NI.GetOutDeg(); e++) {
      if (NI.GetOutNId(e) != NI.GetId()) {
        NbrH.AddKey(NI.GetOutNId(e)); }
    }
    if (IsDir) {
      for (int e = 0; e < NI.GetInDeg(); e++) {
        if (NI.GetInNId(e) != NI.GetId()) {
          NbrH.AddKey(NI.GetInNId(e)); }
      }
    }
    // count connected neighbors
    int OpenCnt=0, CloseCnt=0;
    for (int srcNbr = 0; srcNbr < NbrH.Len(); srcNbr++) {
      const typename PGraph::TObj::TNodeI SrcNode = Graph->GetNI(NbrH.GetKey(srcNbr));
      for (int dstNbr = srcNbr+1; dstNbr < NbrH.Len(); dstNbr++) {
        const int dstNId = NbrH.GetKey(dstNbr);
        if (SrcNode.IsNbrNId(dstNId)) { CloseCnt++; } // is edge
        else { OpenCnt++; }
      }
    }
    IAssert(2*(OpenCnt+CloseCnt) == NbrH.Len()*(NbrH.Len()-1));
    NIdCOTriadV.Add(TIntTr(NI.GetId(), CloseCnt, OpenCnt));
  }
}

template<class PGraph >

int64 TSnap::GetTriadsAll	(	const PGraph &	Graph,
		int64 &	ClosedTriadsX,
		int64 &	OpenTriadsX,
		int	SampleNodes = -1
	)

Computes the number of Closed and Open triads.

Considers the graph as undirected. This function is a duplicate. It is required by Snap.py.

Parameters

SampleNodes

If !=-1 then compute triads only for a random sample of SampleNodes nodes. Useful for approximate but quick computations.

Definition at line 263 of file triad.h.

                                                                                                 {
  return GetTriads(Graph, ClosedTriads, OpenTriads, SampleNodes);
}

template<class PGraph >

int64 TSnap::GetTriangleCnt

(

const PGraph &

Graph

)

Returns the number of triangles in graph Graph.

Definition at line 454 of file triad.h.

                                          {
  const int NNodes = Graph->GetNodes();

  TIntV MapV(NNodes);
  TVec<typename PGraph::TObj::TNodeI> NV(NNodes);
  NV.Reduce(0);

  int MxId = -1;
  int ind = 0;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++)   {
    NV.Add(NI);
    int Id = NI.GetId();
    if (Id > MxId) {
      MxId = Id;
    }
    MapV[ind] = Id;
    ind++;
  }

  TIntV IndV(MxId+1);

  for (int j = 0; j < NNodes; j++) {
    IndV[MapV[j]] = j;
  }

  ind = MapV.Len();

  TVec<TIntV> HigherDegNbrV(ind);

  for (int i = 0; i < ind; i++) {
    HigherDegNbrV[i] = TVec<TInt>();
    HigherDegNbrV[i].Reserve(NV[i].GetDeg());
    HigherDegNbrV[i].Reduce(0);
  }

#ifdef USE_OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
  for (int i = 0; i < ind; i++) {
    typename PGraph::TObj::TNodeI NI = NV[i];
    MergeNbrs<PGraph>(HigherDegNbrV[i], NI);

    int k = 0;
    for (int j = 0; j < HigherDegNbrV[i].Len(); j++) {
      TInt Vert = HigherDegNbrV[i][j];
      TInt Deg = NV[IndV[Vert]].GetDeg();
      if (Deg > NI.GetDeg() ||
         (Deg == NI.GetDeg() && Vert > NI.GetId())) {
        HigherDegNbrV[i][k] = Vert;
        k++;
      }
    }
    HigherDegNbrV[i].Reduce(k);
  }

  int64 cnt = 0;
#ifdef USE_OPENMP
#pragma omp parallel for schedule(dynamic) reduction(+:cnt)
#endif
  for (int i = 0; i < HigherDegNbrV.Len(); i++) {
    for (int j = 0; j < HigherDegNbrV[i].Len(); j++) {
      TInt NbrInd = IndV[HigherDegNbrV[i][j]];

      int64 num = GetCommon(HigherDegNbrV[i], HigherDegNbrV[NbrInd]);
      cnt += num;
    }
  }

  return cnt;
}

template<class PGraph >

PGraph TSnap::GetUnDir

(

const PGraph &

Graph

)

Returs an undirected version of the graph. For every edge (u,v) an edge (v,u) is added (if it does not yet exist).

Definition at line 345 of file alg.h.

                                     {
  PGraph NewGraphPt = PGraph::New();
  *NewGraphPt = *Graph;
  MakeUnDir(NewGraphPt);
  return NewGraphPt;
}

template<class PGraph >

void TSnap::GetUniqueNbrV	(	const PGraph &	Graph,
		const int &	NId,
		TIntV &	NbrV
	)

Returns sorted vector NbrV containing unique in or out neighbors of node NId in graph Graph.

Definition at line 783 of file triad.h.

                                                                     {
  typename PGraph::TObj::TNodeI NI = Graph->GetNI(NId);
  NbrV.Reserve(NI.GetDeg());
  NbrV.Reduce(0);

  int j = 0;
  int k = 0;
  int Prev = -1;
  int InDeg = NI.GetInDeg();
  int OutDeg = NI.GetOutDeg();
  if (InDeg > 0  &&  OutDeg > 0) {
    int v1 = NI.GetInNId(j);
    int v2 = NI.GetOutNId(k);
    while (1) {
      if (v1 <= v2) {
        if (Prev != v1) {
          if (v1 != NId) {
            NbrV.Add(v1);
            Prev = v1;
          }
        }
        j += 1;
        if (j >= InDeg) {
          break;
        }
        v1 = NI.GetInNId(j);
      } else {
        if (Prev != v2) {
          if (v2 != NId) {
            NbrV.Add(v2);
          }
          Prev = v2;
        }
        k += 1;
        if (k >= OutDeg) {
          break;
        }
        v2 = NI.GetOutNId(k);
      }
    }
  }
  while (j < InDeg) {
    int v = NI.GetInNId(j);
    if (Prev != v) {
      if (v != NId) {
        NbrV.Add(v);
      }
      Prev = v;
    }
    j += 1;
  }
  while (k < OutDeg) {
    int v = NI.GetOutNId(k);
    if (Prev != v) {
      if (v != NId) {
        NbrV.Add(v);
      }
      Prev = v;
    }
    k += 1;
  }
}

template<class PGraph >

void TSnap::GetWccs	(	const PGraph &	Graph,
		TCnComV &	CnComV
	)

Returns all weakly connected components in a Graph.

Parameters

CnComV

is a vector of connected components. Each component is defined by the IDs of its member nodes.

Definition at line 376 of file cncom.h.

                                                   {
  typename PGraph::TObj::TNodeI NI;
  THashSet<TInt> VisitedNId(Graph->GetNodes()+1);
  TSnapQueue<int> NIdQ(Graph->GetNodes()+1);
  TIntV CcNIdV;
  CnComV.Clr();  CcNIdV.Gen(1);
  // zero degree nodes
  for (NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NI.GetDeg() == 0) {
      const int NId = NI.GetId();
      VisitedNId.AddKey(NId);
      CcNIdV[0] = NId;  CnComV.Add(CcNIdV);
    }
  }
  // the rest of the nodes
  for (NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    const int NId = NI.GetId();
    if (! VisitedNId.IsKey(NId)) {
      VisitedNId.AddKey(NId);
      NIdQ.Clr(false);  NIdQ.Push(NId);
      CcNIdV.Clr();  CcNIdV.Add(NId);
      while (! NIdQ.Empty()) {
        const typename PGraph::TObj::TNodeI Node = Graph->GetNI(NIdQ.Top());  NIdQ.Pop();
        if (HasGraphFlag(typename PGraph::TObj, gfDirected)) {
          for (int e = 0; e < Node.GetInDeg(); e++) {
            const int InNId = Node.GetInNId(e);
            if (! VisitedNId.IsKey(InNId)) {
              NIdQ.Push(InNId);  VisitedNId.AddKey(InNId);  CcNIdV.Add(InNId); }
          }
        }
        for (int e = 0; e < Node.GetOutDeg(); e++) {
          const int OutNId = Node.GetOutNId(e);
          if (! VisitedNId.IsKey(OutNId)) {
            NIdQ.Push(OutNId);  VisitedNId.AddKey(OutNId);  CcNIdV.Add(OutNId); }
        }
      }
      CcNIdV.Sort(true);
      CnComV.Add(TCnCom(CcNIdV)); // add wcc comoponent
    }
  }
  CnComV.Sort(false);
}

template<class PGraph >

void TSnap::GetWccSzCnt	(	const PGraph &	Graph,
		TIntPrV &	WccSzCnt
	)

Returns a distribution of weakly connected component sizes.

Parameters

WccSzCnt

returns a set of pairs (number of nodes in the component, number of such components)

Definition at line 337 of file cncom.h.

                                                         {
  THashSet<TInt> VisitedNId(Graph->GetNodes());
  TIntH SzToCntH;
  TSnapQueue<int> NIdQ(Graph->GetNodes()+1);
  typename PGraph::TObj::TNodeI NI;
  int Cnt = 0;
  // zero degree nodes
  for (NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NI.GetDeg() == 0) { Cnt++;  VisitedNId.AddKey(NI.GetId()); }
  }
  if (Cnt > 0) SzToCntH.AddDat(1, Cnt);
  // the rest of the nodes
  for (NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (! VisitedNId.IsKey(NI.GetId())) {
      VisitedNId.AddKey(NI.GetId());
      NIdQ.Clr(false);  NIdQ.Push(NI.GetId());
      Cnt = 0;
      while (! NIdQ.Empty()) {
        const typename PGraph::TObj::TNodeI Node = Graph->GetNI(NIdQ.Top());  NIdQ.Pop();
        if (HasGraphFlag(typename PGraph::TObj, gfDirected)) {
          for (int e = 0; e < Node.GetInDeg(); e++) {
            const int InNId = Node.GetInNId(e);
            if (! VisitedNId.IsKey(InNId)) { NIdQ.Push(InNId);  VisitedNId.AddKey(InNId); }
          }
        }
        for (int e = 0; e < Node.GetOutDeg(); e++) {
          const int OutNId = Node.GetOutNId(e);
          if (! VisitedNId.IsKey(OutNId)) { NIdQ.Push(OutNId);  VisitedNId.AddKey(OutNId); }
        }
        Cnt++;
      }
      SzToCntH.AddDat(Cnt) += 1;
    }
  }
  SzToCntH.GetKeyDatPrV(WccSzCnt);
  WccSzCnt.Sort(true);
}

void TSnap::GetWeightedBetweennessCentr	(	const PNEANet	Graph,
		const TIntV &	BtwNIdV,
		TIntFltH &	NodeBtwH,
		const bool &	DoNodeCent,
		TIntPrFltH &	EdgeBtwH,
		const bool &	DoEdgeCent,
		const TFltV &	Attr,
		const bool &	IsDir
	)

Computes (approximate) weighted Beetweenness Centrality of all nodes and all edges of the network.

Definition at line 752 of file centr.cpp.

                                                                                                                                                                                                            {
  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);
  TIntFltH sigma(nodes), d(nodes);
  // init
  for (PNEANet::TObj::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 (Graph->HasFlag(gfDirected) && IsDir) {
          // add all outgoing edges for directed graphs
          EdgeBtwH.AddDat(TIntPr(NI.GetId(), NI.GetOutNId(e)), 0);
        } else {
          // add each edge only once in undirected graphs
          if (NI.GetId() < NI.GetOutNId(e)) {
            EdgeBtwH.AddDat(TIntPr(NI.GetId(), NI.GetOutNId(e)), 0); 
          }
        }
      }
      // add incoming edges in directed graphs that were not added yet
      if (Graph->HasFlag(gfDirected) && !IsDir) {
        for (int e = 0; e < NI.GetInDeg(); e++) {
          if (NI.GetId() < NI.GetInNId(e)  &&
              !Graph->IsEdge(NI.GetId(), NI.GetInNId(e))) {
            EdgeBtwH.AddDat(TIntPr(NI.GetId(), NI.GetInNId(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 PNEANet::TObj::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 PNEANet::TObj::TNodeI NI2 = Graph->GetNI(v);
      S.Push(v);
      const double VDat = d.GetDat(v);
      // iterate over all outgoing edges
      for (int e = 0; e < NI2.GetOutDeg(); e++) {
        const int w = NI2.GetOutNId(e);
        const int eid = NI2.GetOutEId(e);

        if (d.GetDat(w) < 0) { // find w for the first time
          Q.Push(w);
          d.AddDat(w, VDat+Attr[eid]);
        }
        //shortest path to w via v ?
        if (d.GetDat(w) == VDat+Attr[eid]) {
          sigma.AddDat(w) += sigma.GetDat(v);
          P.GetDat(w).Add(v);
        }
      }
      // if ignoring direction in directed networks, iterate over incoming edges
      if (Graph->HasFlag(gfDirected) && !IsDir) {
        for (int e = 0; e < NI2.GetInDeg(); e++) {
          const int w = NI2.GetInNId(e);
          // skip neighbors that are also outgoing
          if (Graph->IsEdge(NI2.GetId(), w)) {
            continue;
          }
          const int eid = NI2.GetInEId(e);

          if (d.GetDat(w) < 0) { // find w for the first time
            Q.Push(w);
            d.AddDat(w, VDat+Attr[eid]);
          }
          //shortest path to w via v ?
          if (d.GetDat(w) == VDat+Attr[eid]) {
            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) {
          if (Graph->HasFlag(gfDirected) && IsDir) {
            EdgeBtwH.AddDat(TIntPr(NId, w)) += c;
          } else {
            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; }
    }
  }
}

void TSnap::GetWeightedBetweennessCentr	(	const PNEANet	Graph,
		TIntFltH &	NIdBtwH,
		TIntPrFltH &	EdgeBtwH,
		const TFltV &	Attr,
		const double &	NodeFrac = 1.0,
		const bool &	IsDir = false
	)

Computes (approximate) weighted Node and Edge Beetweenness Centrality based on a sample of NodeFrac nodes.

Parameters

NIdBtwH	hash table mapping node ids to their corresponding betweenness centrality values.
EdgeBtwH	hash table mapping edges (pairs of node ids) to their corresponding betweenness centrality values.
NodeFrac	quality of approximation. NodeFrac=1.0 gives exact betweenness values.

Definition at line 871 of file centr.cpp.

                                                                                                                                                              {
  TIntV NIdV;  Graph->GetNIdV(NIdV);
  if (NodeFrac < 1.0) { // calculate beetweenness centrality for a subset of nodes
    NIdV.Shuffle(TInt::Rnd);
    for (int i = int((1.0-NodeFrac)*NIdV.Len()); i > 0; i--) {
      NIdV.DelLast(); }
  }
  GetWeightedBetweennessCentr(Graph, NIdV, NodeBtwH, true, EdgeBtwH, true,
    Attr, IsDir);
}

void TSnap::GetWeightedBetweennessCentr	(	const PNEANet	Graph,
		TIntFltH &	NIdBtwH,
		const TFltV &	Attr,
		const double &	NodeFrac = 1.0,
		const bool &	IsDir = false
	)

Computes (approximate) weighted Node Beetweenness Centrality based on a sample of NodeFrac nodes.

Parameters

NIdBtwH	hash table mapping node ids to their corresponding betweenness centrality values.
NodeFrac	quality of approximation. NodeFrac=1.0 gives exact betweenness values.

Definition at line 882 of file centr.cpp.

                                                                                                                                        {
  TIntPrFltH EdgeBtwH;
  TIntV NIdV;  Graph->GetNIdV(NIdV);
  if (NodeFrac < 1.0) { // calculate beetweenness centrality for a subset of nodes
    NIdV.Shuffle(TInt::Rnd);
    for (int i = int((1.0-NodeFrac)*NIdV.Len()); i > 0; i--) {
      NIdV.DelLast(); }
  }
  GetWeightedBetweennessCentr(Graph, NIdV, NodeBtwH, true, EdgeBtwH, false,
    Attr, IsDir);
}

void TSnap::GetWeightedBetweennessCentr	(	const PNEANet	Graph,
		TIntPrFltH &	EdgeBtwH,
		const TFltV &	Attr,
		const double &	NodeFrac = 1.0,
		const bool &	IsDir = false
	)

Computes (approximate) weighted Edge Beetweenness Centrality based on a sample of NodeFrac nodes.

Parameters

EdgeBtwH	hash table mapping edges (pairs of node ids) to their corresponding betweenness centrality values.
NodeFrac	quality of approximation. NodeFrac=1.0 gives exact betweenness values.

Definition at line 894 of file centr.cpp.

                                                                                                                                          {
  TIntFltH NodeBtwH;
  TIntV NIdV;  Graph->GetNIdV(NIdV);
  if (NodeFrac < 1.0) { // calculate beetweenness centrality for a subset of nodes
    NIdV.Shuffle(TInt::Rnd);
    for (int i = int((1.0-NodeFrac)*NIdV.Len()); i > 0; i--) {
      NIdV.DelLast(); }
  }
  GetWeightedBetweennessCentr(Graph, NIdV, NodeBtwH, false, EdgeBtwH, true,
    Attr, IsDir);
}

double TSnap::GetWeightedClosenessCentr	(	const PNEANet	Graph,
		const int &	NId,
		const TFltV &	Attr,
		const bool &	Normalized = true,
		const bool &	IsDir = false
	)

Returns Closeness centrality of a given node NId. Closeness centrality of a node is defined as 1/FarnessCentrality.

Definition at line 745 of file centr.cpp.

                                                                                                                                    {
  const double Farness = GetWeightedFarnessCentr(Graph, NId, Attr, Normalized, IsDir);
  if (Farness != 0.0) { return 1.0/Farness; }
  else { return 0.0; }
  return 0.0;
}

double TSnap::GetWeightedFarnessCentr	(	const PNEANet	Graph,
		const int &	NId,
		const TFltV &	Attr,
		const bool &	Normalized = true,
		const bool &	IsDir = false
	)

Returns weighted Farness centrality of a given node NId. Farness centrality of a node is the average shortest path length to all other nodes that reside is the same connected component as the given node.

Definition at line 726 of file centr.cpp.

                                                                                                                                  {
  TIntFltH NDistH(Graph->GetNodes());
  
  GetWeightedShortestPath(Graph, NId, NDistH, Attr);
  
  double sum = 0;
  for (TIntFltH::TIter I = NDistH.BegI(); I < NDistH.EndI(); I++) {
    sum += I->Dat();
  }
  if (NDistH.Len() > 1) { 
    double centr = sum/double(NDistH.Len()-1); 
    if (Normalized) {
      centr *= (Graph->GetNodes() - 1)/double(NDistH.Len()-1);
    }
    return centr;
  }
  else { return 0.0; }
}

int TSnap::GetWeightedPageRank	(	const PNEANet	Graph,
		TIntFltH &	PRankH,
		const TStr &	Attr,
		const double &	C,
		const double &	Eps,
		const int &	MaxIter
	)

Weighted PageRank (TODO: Use template)

Definition at line 396 of file centr.cpp.

                                                                                                                                         {
  if (!Graph->IsFltAttrE(Attr)) return -1;

  TFltV Weights = Graph->GetFltAttrVecE(Attr);

  int mxid = Graph->GetMxNId();
  TFltV OutWeights(mxid);
  Graph->GetWeightOutEdgesV(OutWeights, Weights);

  const int NNodes = Graph->GetNodes();
  //const double OneOver = 1.0/double(NNodes);
  PRankH.Gen(NNodes);
  for (TNEANet::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    PRankH.AddDat(NI.GetId(), 1.0/NNodes);
    //IAssert(NI.GetId() == PRankH.GetKey(PRankH.Len()-1));
  }
  TFltV TmpV(NNodes);
  for (int iter = 0; iter < MaxIter; iter++) {
    int j = 0;
    for (TNEANet::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++, j++) {
      TmpV[j] = 0;
      for (int e = 0; e < NI.GetInDeg(); e++) {
        const int InNId = NI.GetInNId(e);
        const TFlt OutWeight = OutWeights[InNId];
        int EId = Graph->GetEId(InNId, NI.GetId());
        const TFlt Weight = Weights[Graph->GetFltKeyIdE(EId)];
        if (OutWeight > 0) {
          TmpV[j] += PRankH.GetDat(InNId) * Weight / OutWeight; }
      }
      TmpV[j] =  C*TmpV[j]; // Berkhin (the correct way of doing it)
      //TmpV[j] =  C*TmpV[j] + (1.0-C)*OneOver; // iGraph
    }
    double diff=0, sum=0, NewVal;
    for (int i = 0; i < TmpV.Len(); i++) { sum += TmpV[i]; }
    const double Leaked = (1.0-sum) / double(NNodes);
    for (int i = 0; i < PRankH.Len(); i++) { // re-instert leaked PageRank
      NewVal = TmpV[i] + Leaked; // Berkhin
      //NewVal = TmpV[i] / sum;  // iGraph
      diff += fabs(NewVal-PRankH[i]);
      PRankH[i] = NewVal;
    }
    if (diff < Eps) { break; }
  }
  return 0;
}

int TSnap::GetWeightedPageRankMP	(	const PNEANet	Graph,
		TIntFltH &	PRankH,
		const TStr &	Attr,
		const double &	C,
		const double &	Eps,
		const int &	MaxIter
	)

Definition at line 443 of file centr.cpp.

                                                                                                                                           {
  if (!Graph->IsFltAttrE(Attr)) return -1;
  const int NNodes = Graph->GetNodes();
  TVec<TNEANet::TNodeI> NV;

  //const double OneOver = 1.0/double(NNodes);
  PRankH.Gen(NNodes);
  int MxId = 0;

  for (TNEANet::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    NV.Add(NI);
    PRankH.AddDat(NI.GetId(), 1.0/NNodes);
    int Id = NI.GetId();
    if (Id > MxId) {
      MxId = Id;
    }
  }

  TFltV PRankV(MxId+1);
  TFltV OutWeights(MxId+1);

  TFltV Weights = Graph->GetFltAttrVecE(Attr);

  #pragma omp parallel for schedule(dynamic,10000)
  for (int j = 0; j < NNodes; j++) {
    TNEANet::TNodeI NI = NV[j];
    int Id = NI.GetId();
    OutWeights[Id] = Graph->GetWeightOutEdges(NI, Attr);
    PRankV[Id] = 1/NNodes;
  }

  TFltV TmpV(NNodes);
  for (int iter = 0; iter < MaxIter; iter++) {

    #pragma omp parallel for schedule(dynamic,10000)
    for (int j = 0; j < NNodes; j++) {
      TNEANet::TNodeI NI = NV[j];
      TFlt Tmp = 0;
      for (int e = 0; e < NI.GetInDeg(); e++) {
        const int InNId = NI.GetInNId(e);

        const TFlt OutWeight = OutWeights[InNId];

        int EId = Graph->GetEId(InNId, NI.GetId());
        const TFlt Weight = Weights[Graph->GetFltKeyIdE(EId)];

        if (OutWeight > 0) {
          Tmp += PRankH.GetDat(InNId) * Weight / OutWeight;
        }
      }
      TmpV[j] =  C*Tmp; // Berkhin (the correct way of doing it)
      //TmpV[j] =  C*TmpV[j] + (1.0-C)*OneOver; // iGraph
    }

    double sum = 0;
    #pragma omp parallel for reduction(+:sum) schedule(dynamic,10000)
    for (int i = 0; i < TmpV.Len(); i++) { sum += TmpV[i]; }
    const double Leaked = (1.0-sum) / double(NNodes);

    double diff = 0;
    #pragma omp parallel for reduction(+:diff) schedule(dynamic,10000)
    for (int i = 0; i < NNodes; i++) {
      TNEANet::TNodeI NI = NV[i];
      double NewVal = TmpV[i] + Leaked; // Berkhin
      //NewVal = TmpV[i] / sum;  // iGraph
      int Id = NI.GetId();
      diff += fabs(NewVal-PRankV[Id]);
      PRankV[Id] = NewVal;
    }
    if (diff < Eps) { break; }
  }

  #pragma omp parallel for schedule(dynamic,10000)
  for (int i = 0; i < NNodes; i++) {
    TNEANet::TNodeI NI = NV[i];
    PRankH[i] = PRankV[NI.GetId()];
  }

  return 0;
}

int TSnap::GetWeightedShortestPath	(	const PNEANet	Graph,
		const int &	SrcNId,
		TIntFltH &	NIdDistH,
		const TFltV &	Attr
	)

Dijkstra Algorithm For more info see: https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm

Definition at line 700 of file centr.cpp.

                                                                               {
  TIntV frontier;

  NIdDistH.Clr(false); NIdDistH.AddDat(SrcNId, 0);
  frontier.Add(SrcNId);
  while (! frontier.Empty()) {
    const int NId = findMinimum(frontier, NIdDistH);
    const PNEANet::TObj::TNodeI NodeI = Graph->GetNI(NId);
    for (int v = 0; v < NodeI.GetOutDeg(); v++) {
      int DstNId = NodeI.GetOutNId(v);
      int EId = NodeI.GetOutEId(v);

      if (! NIdDistH.IsKey(DstNId)) {
        NIdDistH.AddDat(DstNId, NIdDistH.GetDat(NId) + Attr[EId]);
        frontier.Add(DstNId);
      } else {
        if (NIdDistH.GetDat(DstNId) > NIdDistH.GetDat(NId) + Attr[EId]) {
          NIdDistH.GetDat(DstNId) = NIdDistH.GetDat(NId) + Attr[EId]; 
        }
      }
    }
  }
  return 0;
}

void TSnap::GlobalRelabel	(	PNEANet &	Net,
		TPRManager &	PRM,
		const int &	SrcNId,
		const int &	SnkNId
	)

Implements the Global Relabeling heuristic.

Since labels reflect an estimate of the distance from a node to the sink node, every now and then the Global Relabel heuristic will be run. This BFS over the residual network starting from the sink and updates each nodes label as the distance to the sink. Unreacheable nodes from the sink have their labels set to N, where N is the number of nodes.

Definition at line 363 of file flow.cpp.

                                                                                         {
  TIntQ NodeQ;
  int size = Net->GetMxNId();
  TIntV NodeV(size);
  for (int i = 0; i < size; i++) { NodeV[i] = 0; }
  NodeQ.Push(SnkNId);
  NodeV[SnkNId] = 1;
  int MaxLabel = PRM.GetMaxLabel();
  while (!NodeQ.Empty()) {
    // Backward search
    int NId = NodeQ.Top(); NodeQ.Pop();
    const TNEANet::TNodeI &NI = Net->GetNI(NId);
    // Check all edges that point out of the current node for those over which flow can be returned.
    for (int EdgeN = 0; EdgeN < NI.GetOutDeg(); EdgeN++) {
      int OutNId = NI.GetOutNId(EdgeN);
      int EId = NI.GetOutEId(EdgeN);
      if (!NodeV[OutNId] && PRM.Flow(EId) > 0) {
        NodeV[OutNId] = 1;
        NodeQ.Push(OutNId);
        PRM.SetLabel(OutNId, PRM.Label(NId) + 1);
      }
    }
    // Check all edges that point into the current node for those over which flow can be added.
    for (int EdgeN = 0; EdgeN < NI.GetInDeg(); EdgeN++) {
      int InNId = NI.GetInNId(EdgeN);
      int EId = NI.GetInEId(EdgeN);
      if (!NodeV[InNId] && PRM.Capacity(EId) > PRM.Flow(EId)) {
        NodeV[InNId] = 1;
        NodeQ.Push(InNId);
        PRM.SetLabel(InNId, PRM.Label(NId) + 1);
      }
    }
  }

  for (TNEANet::TNodeI NI = Net->BegNI(); NI != Net->EndNI(); NI++) {
    int NId = NI.GetId();
    if (NodeV[NId]) {
      if (PRM.Excess(NId) > 0 && PRM.Label(NId) < MaxLabel && NId != SnkNId) {
        if (!PRM.IsActive(NId)) { PRM.PushActive(NId); }
      }
    } else {
      if (PRM.IsActive(NId)) { PRM.RemoveActive(NId); }
      PRM.SetLabel(NId, MaxLabel);
    }
  }
}

double TSnap::Infomap	(	PUNGraph &	Graph,
		TCnComV &	CmtyV
	)

Rosvall-Bergstrom community detection algorithm based on information theoretic approach. See: Rosvall M., Bergstrom C. T., Maps of random walks on complex networks reveal community structure, Proc. Natl. Acad. Sci. USA 105, 1118-1123 (2008)

Definition at line 339 of file cmty.cpp.

                                               {

  TIntFltH PAlpha; // probability of visiting node alpha
  TIntH Module; // module of each node
  TIntFltH Qi; // probability of leaving each module

  double SumPAlphaLogPAlpha = 0.0;
  int Br = 0;
  const int e = Graph->GetEdges();

  // initial values
  for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    int nodeId = NI.GetId();
    int nodeDeg = NI.GetDeg();
    float d = ((float)nodeDeg / (float)(2 * e));
    PAlpha.AddDat(nodeId, d);
    SumPAlphaLogPAlpha += d*log(d);
    Module.AddDat(nodeId, Br);
    Qi.AddDat(Br, 1.0);
    Br += 1;
  }

  double MinCodeLength = TSnapDetail::Equation(PAlpha, SumPAlphaLogPAlpha, Qi);
  double NewCodeLength, PrevIterationCodeLength = 0.0;
  int OldModule, NewModule;

  TIntV nodes;
  for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++)
    nodes.Add(NI.GetId());

  do {
    PrevIterationCodeLength = MinCodeLength;
    TRnd rnd;
    rnd.Randomize();
    nodes.Shuffle(rnd);
    for (int ndcounter = 0; ndcounter<nodes.Len(); ndcounter++) {
      MinCodeLength = TSnapDetail::Equation(PAlpha, SumPAlphaLogPAlpha, Qi);
      int nodeId = nodes[ndcounter];
      TUNGraph::TNodeI NI = Graph->GetNI(nodeId);
      for (int i = 0; i<NI.GetDeg(); i++) {

        OldModule = Module.GetDat(nodeId);
        NewModule = Module.GetDat(NI.GetNbrNId(i));

        if (OldModule != NewModule){

          Module.AddDat(nodeId, NewModule);

          TSnapDetail::MapEquationNew2Modules(Graph, Module, Qi, OldModule, NewModule);
          NewCodeLength = TSnapDetail::Equation(PAlpha, SumPAlphaLogPAlpha, Qi);
          if (NewCodeLength<MinCodeLength) {
            MinCodeLength = NewCodeLength;
            OldModule = NewModule;
          }
          else {
            Module.AddDat(nodeId, OldModule);
          }
        }
      }
    }
  } while (MinCodeLength<PrevIterationCodeLength);

  Module.SortByDat(true);

  int Mod = -1;
  for (int i = 0; i<Module.Len(); i++) {
    if (Module[i]>Mod){
      Mod = Module[i];
      TCnCom t;
      for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++){
        if (Module.GetDat(NI.GetId()) == Mod)
          t.Add(NI.GetId());
      }
      CmtyV.Add(t);
    }
  }

  return MinCodeLength;
}

double TSnap::InfomapOnline	(	PUNGraph &	Graph,
		int	n1,
		int	n2,
		TIntFltH &	PAlpha,
		double &	SumPAlphaLogPAlpha,
		TIntFltH &	Qi,
		TIntH &	Module,
		int &	Br,
		TCnComV &	CmtyV
	)

Definition at line 419 of file cmty.cpp.

                                                                                                                                                          {

  double MinCodeLength = TSnapDetail::InfomapOnlineIncrement(Graph, n1, n2, PAlpha, SumPAlphaLogPAlpha, Qi, Module, Br);

  Module.SortByDat(true);

  int Mod = -1;
  for (int i = 0; i<Module.Len(); i++) {
    if (Module[i]>Mod){
      Mod = Module[i];
      TCnCom t;
      for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++){
        if (Module.GetDat(NI.GetId()) == Mod)
          t.Add(NI.GetId());
      }
      CmtyV.Add(t);
    }
  }

  return MinCodeLength;
}

int TSnap::Intersect	(	TUNGraph::TNodeI	Node,
		TIntH	NNodes
	)

Intersect.

Definition at line 584 of file centr.cpp.

                                                {
  int br=0;
  for (int i=0; i<Node.GetDeg(); i++)
  {
    if (NNodes.IsKey(Node.GetNbrNId(i)))
      br++;
  }
  if (NNodes.IsKey(Node.GetId()))
    br++;

  return br;
}

int TSnap::Intersect	(	TUNGraph::TNodeI	Node,
		TStr	NNodes
	)

Intersect.

Definition at line 597 of file centr.cpp.

                                               {
  int br=0;

  TInt digi = -1;
  TStr buf = "";

  for (int i=0; i<Node.GetDeg(); i++)
  {
    digi = Node.GetNbrNId(i);
    TStr buf = digi.GetStr();

    if (NNodes.IsStrIn(buf.CStr()))
    br++;
  }

  digi = Node.GetId();
  buf = digi.GetStr();

  if (NNodes.IsStrIn(buf.CStr()))
    br++;

  return br;
}

int TSnap::Intersect	(	TUNGraph::TNodeI	Node,
		int *	NNodes,
		int	NNodes_br
	)

Intersect.

Definition at line 621 of file centr.cpp.

                                                              {
  int br = 0;
  int neig;
  for (int i=0; i<Node.GetDeg(); i++)
  {
    neig = Node.GetNbrNId(i);
    for (int j=0; j<NNodes_br; j++)
    {
    if (neig == NNodes[j])
    {
      br++;
      j = NNodes_br;
    }
    }
  }

  neig = Node.GetId();
  for (int j=0; j<NNodes_br; j++)
  {
    if (neig == NNodes[j])
    {
      br++;
      j = NNodes_br;
    }
  }

  return br;
}

int TSnap::Intersect1	(	TUNGraph::TNodeI	Node,
		TStr	NNodes
	)

Definition at line 650 of file centr.cpp.

                                                {
  int br=0;
  for (int i=0; i<Node.GetDeg(); i++)
  {
    TInt digi = Node.GetNbrNId(i);
    TStr buf = "";
    buf = digi.GetStr();

    if (NNodes.SearchStr(buf.CStr())!=-1)
    br++;
  }
  
  TInt digi = Node.GetId();
  TStr buf = digi.GetStr();

  if (NNodes.SearchStr(buf.CStr())!=-1)
    br++;

  return br;
}

int TSnap::IntFlowBiDBFS	(	const PNEANet &	Net,
		const int &	CapIndex,
		TIntV &	Flow,
		TIntQ &	FwdNodeQ,
		TIntH &	PredEdgeH,
		TIntQ &	BwdNodeQ,
		TIntH &	SuccEdgeH,
		const int &	SrcNId,
		const int &	SnkNId
	)

Definition at line 4 of file flow.cpp.

                                                                                                                                                                                     {
  FwdNodeQ.Push(SrcNId);
  PredEdgeH.AddDat(SrcNId, -1);
  BwdNodeQ.Push(SnkNId);
  SuccEdgeH.AddDat(SnkNId, -1);
  while (!FwdNodeQ.Empty() && !BwdNodeQ.Empty()) {
    // Forward search
    const TNEANet::TNodeI &FwdNI = Net->GetNI(FwdNodeQ.Top()); FwdNodeQ.Pop();
    // Check all edges that point into the current node for those over which flow can be returned.
    for (int EdgeN = 0; EdgeN < FwdNI.GetInDeg(); EdgeN++) {
      int NextNId = FwdNI.GetInNId(EdgeN);
      int NextEId = FwdNI.GetInEId(EdgeN);
      if (!PredEdgeH.IsKey(NextNId) && Flow[NextEId] > 0) {
        PredEdgeH.AddDat(NextNId, NextEId);
        if (SuccEdgeH.IsKey(NextNId)) {
          return NextNId;
        }
        FwdNodeQ.Push(NextNId);
      }
    }
    // Check all edges that point out of the current node for those over which flow can be added.
    for (int EdgeN = 0; EdgeN < FwdNI.GetOutDeg(); EdgeN++) {
      int NextNId = FwdNI.GetOutNId(EdgeN);
      int NextEId = FwdNI.GetOutEId(EdgeN);
      if (!PredEdgeH.IsKey(NextNId) && Net->GetIntAttrIndDatE(NextEId, CapIndex) > Flow[NextEId]) {
        PredEdgeH.AddDat(NextNId, NextEId);
        if (SuccEdgeH.IsKey(NextNId)) {
          return NextNId;
        }
        FwdNodeQ.Push(NextNId);
      }
    }
    // Backward search
    const TNEANet::TNodeI &BwdNI = Net->GetNI(BwdNodeQ.Top());  BwdNodeQ.Pop();
    // Check all edges that point out of the current node for those over which flow can be returned.
    for (int EdgeN = 0; EdgeN < BwdNI.GetOutDeg(); EdgeN++) {
      int PrevNId = BwdNI.GetOutNId(EdgeN);
      int PrevEId = BwdNI.GetOutEId(EdgeN);
      if (!SuccEdgeH.IsKey(PrevNId) && Flow[PrevEId] > 0) {
        SuccEdgeH.AddDat(PrevNId, PrevEId);
        if (PredEdgeH.IsKey(PrevNId)) {
          return PrevNId;
        }
        BwdNodeQ.Push(PrevNId);
      }
    }
    // Check all edges that point into the current node for those over which flow can be added.
    for (int EdgeN = 0; EdgeN < BwdNI.GetInDeg(); EdgeN++) {
      int PrevNId = BwdNI.GetInNId(EdgeN);
      int PrevEId = BwdNI.GetInEId(EdgeN);
      if (!SuccEdgeH.IsKey(PrevNId) && Net->GetIntAttrIndDatE(PrevEId, CapIndex) > Flow[PrevEId]) {
        SuccEdgeH.AddDat(PrevNId, PrevEId);
        if (PredEdgeH.IsKey(PrevNId)) {
          return PrevNId;
        }
        BwdNodeQ.Push(PrevNId);
      }
    }
  }
  return -1;
}

bool TSnap::IsAllValVNeg	(	TFltV &	ValV,
		const bool &	InvertSign
	)

Definition at line 163 of file gsvd.cpp.

                                                       {
  bool IsAllNeg=true;
  for (int i = 0; i < ValV.Len(); i++) {
    if (ValV[i]>0.0) { IsAllNeg=false; break; }
  }
  if (IsAllNeg && InvertSign) {
    for (int i = 0; i < ValV.Len(); i++) { 
      ValV[i] = -ValV[i]; }
  }
  return IsAllNeg;
}

template<class PGraph >

bool TSnap::IsConnected

(

const PGraph &

Graph

)

Tests whether the Graph is (weakly) connected.

Definition at line 305 of file cncom.h.

                                      {
  return IsWeaklyConn(Graph);
}

template<class PGraph >

bool TSnap::IsTree	(	const PGraph &	Graph,
		int &	RootNIdX
	)

Definition at line 460 of file alg.h.

                                               {
  if (Graph->GetNodes() == 1 && Graph->GetEdges() == 0) {
    RootNId = Graph->BegNI().GetId();
    return true;
  }
  RootNId = -1;
  if (Graph->GetNodes() != Graph->GetEdges()+1) { return false; }
  int NZeroOutDeg = 0;
  int ZeroOutDegN = -1;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NI.GetOutDeg() == 0) {
      ZeroOutDegN = NI.GetId();  NZeroOutDeg++;
    }
    if (NI.GetDeg() == 0) { return false; } // isolated nodes
  }
  if (NZeroOutDeg==1) {
    if (! TSnap::IsConnected(Graph)) { return false; }
    RootNId = ZeroOutDegN;  return true;
  }
  return false;
}

template<class PGraph >

bool TSnap::IsWeaklyConn

(

const PGraph &

Graph

)

Tests whether the Graph is weakly connected.

Definition at line 310 of file cncom.h.

                                       {
  if (Graph->Empty()) {
    return true;
  }
  THashSet<TInt> VisitedNId(Graph->GetNodes());
  TSnapQueue<int> NIdQ(Graph->GetNodes()+1);
  typename PGraph::TObj::TNodeI NI;
  // the rest of the nodes
  NIdQ.Push(Graph->BegNI().GetId());
  while (! NIdQ.Empty()) {
    const typename PGraph::TObj::TNodeI Node = Graph->GetNI(NIdQ.Top());  NIdQ.Pop();
    if (HasGraphFlag(typename PGraph::TObj, gfDirected)) {
      for (int e = 0; e < Node.GetInDeg(); e++) {
        const int InNId = Node.GetInNId(e);
        if (! VisitedNId.IsKey(InNId)) { NIdQ.Push(InNId);  VisitedNId.AddKey(InNId); }
      }
    }
    for (int e = 0; e < Node.GetOutDeg(); e++) {
      const int OutNId = Node.GetOutNId(e);
      if (! VisitedNId.IsKey(OutNId)) { NIdQ.Push(OutNId);  VisitedNId.AddKey(OutNId); }
    }
  }
  if (VisitedNId.Len() < Graph->GetNodes()) { return false; }
  return true;
}

template<class PGraph >

PGraph TSnap::LoadConnList

(

const TStr &

InFNm

)

Loads a (directed, undirected or multi) graph from a text file InFNm with 1 node and all its edges in a single line.

Loads Whitespace separated file of several columns: <source node="" id>=""> <destination node="" id1>=""> <destination node="" id2>="">

Whitespace separated file of several columns: <source node="" id>=""> <destination node="" id1>=""> <destination node="" id2>=""> ... First column of each line contains a source node id followed by ids of the destination nodes. For example, '1 2 3' encodes edges 1–>2 and 1–>3. Note that this format allows for saving isolated nodes.

Definition at line 169 of file gio.h.

                                       {
  TSsParser Ss(InFNm, ssfWhiteSep, true, true, true);
  PGraph Graph = PGraph::TObj::New();
  while (Ss.Next()) {
    if (! Ss.IsInt(0)) { continue; }
    const int SrcNId = Ss.GetInt(0);
    if (! Graph->IsNode(SrcNId)) { Graph->AddNode(SrcNId); }
    for (int dst = 1; dst < Ss.Len(); dst++) {
      const int DstNId = Ss.GetInt(dst);
      if (! Graph->IsNode(DstNId)) { Graph->AddNode(DstNId); }
      Graph->AddEdge(SrcNId, DstNId);
    }
  }
  Graph->Defrag();
  return Graph;
}

template<class PGraph >

PGraph TSnap::LoadConnListStr	(	const TStr &	InFNm,
		TStrHash< TInt > &	StrToNIdH
	)

Loads a (directed, undirected or multi) graph from a text file InFNm with 1 node and all its edges in a single line.

Loads Whitespace separated file of several columns: <source node="" id>=""> <destination node="" id1>=""> <destination node="" id2>="">, with a mapping of strings to node IDs.

Whitespace separated file of several columns: <source node="" name>=""> <destination node name 1> <destination node name 2> ... First colum of each line contains a source node name followed by ids of the destination nodes. For example, 'A B C' encodes edges A–>B and A–>C. Note that this format allows for saving isolated nodes. stores the mapping from node names to node ids.

Definition at line 193 of file gio.h.

                                                                     {
  TSsParser Ss(InFNm, ssfWhiteSep, true, true, true);
  PGraph Graph = PGraph::TObj::New();
  while (Ss.Next()) {
    const int SrcNId = StrToNIdH.AddDatId(Ss[0]);
    if (! Graph->IsNode(SrcNId)) { Graph->AddNode(SrcNId); }
    for (int dst = 1; dst < Ss.Len(); dst++) {
      const int DstNId = StrToNIdH.AddDatId(Ss[dst]);
      if (! Graph->IsNode(DstNId)) { Graph->AddNode(DstNId); }
      Graph->AddEdge(SrcNId, DstNId);
    }
  }
  Graph->Defrag();
  return Graph;
}

int TSnap::LoadCrossNet	(	TCrossNet &	Graph,
		PTable	Table,
		const TStr &	SrcCol,
		const TStr &	DstCol,
		TStrV &	EdgeAttrV
	)

Loads the edges from the TTable and EdgeAttrV specifies columns containing edge attributes.

Definition at line 69 of file conv.cpp.

{

  const TAttrType NodeType = Table->GetColType(SrcCol);
  Assert(NodeType == Table->GetColType(DstCol));
  const TInt SrcColIdx = Table->GetColIdx(SrcCol);
  const TInt DstColIdx = Table->GetColIdx(DstCol);

  // node values - i.e. the unique values of src/dst col
  //THashSet<TInt> IntNodeVals; // for both int and string node attr types.
  THash<TFlt, TInt> FltNodeVals;

  // make single pass over all rows in the table
  for (int CurrRowIdx = 0; CurrRowIdx < (Table->Next).Len(); CurrRowIdx++) {
    if ((Table->Next)[CurrRowIdx] == Table->Invalid) {
      continue;
    }

    // add src and dst nodes to graph if they are not seen earlier
    TInt SVal, DVal;
    if (NodeType == atFlt) {
      return -1;
    } else if (NodeType == atInt || NodeType == atStr) {
      if (NodeType == atInt) {
        SVal = (Table->IntCols)[SrcColIdx][CurrRowIdx];
        DVal = (Table->IntCols)[DstColIdx][CurrRowIdx];
      } else {
        SVal = (Table->StrColMaps)[SrcColIdx][CurrRowIdx];
        if (strlen(Table->GetContextKey(SVal)) == 0) { continue; }  //illegal value
        DVal = (Table->StrColMaps)[DstColIdx][CurrRowIdx];
        if (strlen(Table->GetContextKey(DVal)) == 0) { continue; }  //illegal value
      }
    }

    // add edge and edge attributes
    if (Graph.AddEdge(SVal, DVal, CurrRowIdx) == -1) { return -1; }

    // Aggregate edge attributes and add to graph
    for (TInt i = 0; i < EdgeAttrV.Len(); i++) {
      TStr ColName = EdgeAttrV[i];
      TAttrType T = Table->GetColType(ColName);
      TInt Index = Table->GetColIdx(ColName);
      switch (T) {
        case atInt:
          Graph.AddIntAttrDatE(CurrRowIdx, Table->IntCols[Index][CurrRowIdx], ColName);
          break;
        case atFlt:
          Graph.AddFltAttrDatE(CurrRowIdx, Table->FltCols[Index][CurrRowIdx], ColName);
          break;
        case atStr:
          Graph.AddStrAttrDatE(CurrRowIdx, Table->GetStrValIdx(Index, CurrRowIdx), ColName);
          break;
      }
    }
  }
  return 1;
}

int TSnap::LoadCrossNetToNet	(	PMMNet	Graph,
		const TStr &	Mode1,
		const TStr &	Mode2,
		const TStr &	CrossName,
		PTable	Table,
		const TStr &	SrcCol,
		const TStr &	DstCol,
		TStrV &	EdgeAttrV
	)

Loads a crossnet from Mode1 to Mode2, with name CrossName, from the provided TTable. EdgeAttrV specifies edge attributes.

Definition at line 60 of file conv.cpp.

{
  Graph->AddCrossNet(Mode1, Mode2, CrossName);
  TCrossNet& Net = Graph->GetCrossNetByName(CrossName);
  return LoadCrossNet(Net, Table, SrcCol, DstCol, EdgeAttrV);
}

PNGraph TSnap::LoadDyNet

(

const TStr &

FNm

)

For more info see ORA Network Analysis Data (http://www.casos.cs.cmu.edu/computational_tools/data2.php)

Loads a directed network in the DyNetML format. Loads only the first network in the file FNm.

Definition at line 296 of file gio.cpp.

                                   {
  TXmlLx XmlLx(TZipIn::IsZipFNm(FNm)?TZipIn::New(FNm):TFIn::New(FNm), xspTruncate);
  THashSet<TStr> NIdStr;
  while (XmlLx.GetSym()!=xsyEof) {
    if (XmlLx.Sym==xsySTag && XmlLx.TagNm=="network") {
      PNGraph G = TNGraph::New();
      XmlLx.GetSym();
      while (XmlLx.TagNm=="link") {
        TStr Str1, Val1, Str2, Val2;
        XmlLx.GetArg(0, Str1, Val1);  XmlLx.GetArg(1, Str2, Val2);
        IAssert(Str1=="source" && Str2=="target");
        NIdStr.AddKey(Val1); NIdStr.AddKey(Val2);
        const int src=NIdStr.GetKeyId(Val1);
        const int dst=NIdStr.GetKeyId(Val2);
        if (! G->IsNode(src)) { G->AddNode(src); }
        if (! G->IsNode(dst)) { G->AddNode(dst); }
        G->AddEdge(src, dst);
        XmlLx.GetSym();
      }
      return G;
    }
  }
  return PNGraph();
}

TVec< PNGraph > TSnap::LoadDyNetGraphV

(

const TStr &

FNm

)

For more info see ORA Network Analysis Data (http://www.casos.cs.cmu.edu/computational_tools/data2.php)

Loads directed networks in the DyNetML format. Loads all the networks in the file FNm.

Definition at line 322 of file gio.cpp.

                                               {
  TXmlLx XmlLx(TZipIn::IsZipFNm(FNm)?TZipIn::New(FNm):TFIn::New(FNm), xspTruncate);
  TVec<PNGraph> GraphV;
  THashSet<TStr> NIdStr;
  while (XmlLx.GetSym()!=xsyEof) {
    if (XmlLx.Sym==xsySTag && XmlLx.TagNm=="network") {
      PNGraph G = TNGraph::New();
      GraphV.Add(G);
      XmlLx.GetSym();
      while (XmlLx.TagNm=="link") {
        TStr Str1, Val1, Str2, Val2;
        XmlLx.GetArg(0, Str1, Val1);  XmlLx.GetArg(1, Str2, Val2);
        IAssert(Str1=="source" && Str2=="target");
        NIdStr.AddKey(Val1); NIdStr.AddKey(Val2);
        const int src=NIdStr.GetKeyId(Val1);
        const int dst=NIdStr.GetKeyId(Val2);
        if (! G->IsNode(src)) { G->AddNode(src); }
        if (! G->IsNode(dst)) { G->AddNode(dst); }
        G->AddEdge(src, dst);
        XmlLx.GetSym();
      }
    }
  }
  return GraphV;
}

template<class PGraph >

PGraph TSnap::LoadEdgeList	(	const TStr &	InFNm,
		const int &	SrcColId,
		const int &	DstColId
	)

Loads a (directed, undirected or multi) graph from a text file InFNm with 1 edge per line (whitespace separated columns, integer node ids).

Loads the format saved by TSnap::SaveEdgeList()

Whitespace separated file of several columns: ... <source node="" id>=""> ... <destination node="" id>=""> ... SrcColId and DstColId are column indexes of source/destination (integer!) node ids. This means there is one edge per line and node IDs are assumed to be integers.

Definition at line 84 of file gio.h.

                                                                                 {
  TSsParser Ss(InFNm, ssfWhiteSep, true, true, true);
  PGraph Graph = PGraph::TObj::New();
  int SrcNId, DstNId;

  while (Ss.Next()) {
    if (! Ss.GetInt(SrcColId, SrcNId) || ! Ss.GetInt(DstColId, DstNId)) { continue; }
    if (! Graph->IsNode(SrcNId)) { Graph->AddNode(SrcNId); }
    if (! Graph->IsNode(DstNId)) { Graph->AddNode(DstNId); }
    Graph->AddEdge(SrcNId, DstNId);
  }
  Graph->Defrag();
  return Graph;
}

template<class PGraph >

PGraph TSnap::LoadEdgeList	(	const TStr &	InFNm,
		const int &	SrcColId,
		const int &	DstColId,
		const char &	Separator
	)

Loads a (directed, undirected or multi) graph from a text file InFNm with 1 edge per line ('Separator' separated columns, integer node ids).

Loads the format saved by TSnap::SaveEdgeList() if we set Separator=''.

'Separator' separated file of several columns: ... <source node="" id>=""> ... <destination node="" id>=""> ... SrcColId and DstColId are column indexes of source/destination (integer!) node ids. This means there is one edge per line and node IDs are assumed to be integers.

Definition at line 105 of file gio.h.

                                                                                                        {
  TSsParser Ss(InFNm, Separator);
  PGraph Graph = PGraph::TObj::New();
  int SrcNId, DstNId;
  while (Ss.Next()) {
    if (! Ss.GetInt(SrcColId, SrcNId) || ! Ss.GetInt(DstColId, DstNId)) { continue; }
    if (! Graph->IsNode(SrcNId)) { Graph->AddNode(SrcNId); }
    if (! Graph->IsNode(DstNId)) { Graph->AddNode(DstNId); }
    Graph->AddEdge(SrcNId, DstNId);
  }
  Graph->Defrag();
  return Graph;
}

PNEANet TSnap::LoadEdgeListNet	(	const TStr &	InFNm,
		const char &	Separator
	)

Loads a network from the text file InFNm with 1 node/edge per line ('Separator' separated columns, integer node id(s) + node/edge attributes).

Definition at line 138 of file gio.cpp.

                                                                  {
  PNEANet Graph = PNEANet::New();
  TSsParser Ss(InFNm, Separator, true, false, false);
  bool isSchemaLine = false;

  while (isSchemaLine || Ss.Next()) {
    isSchemaLine = false;
    if (Ss.GetFlds() == 0) continue;
    if (NODES_START == Ss.GetFld(0)) {
      // Map node attribute names to column number in the file.
      TStrIntH IntAttrNVals;
      TStrIntH FltAttrNVals;
      TStrIntH StrAttrNVals;
      int NColId = -1;
      ReadNodeSchemaFromFile(Ss, Separator, NColId, IntAttrNVals, FltAttrNVals, StrAttrNVals);
      isSchemaLine = ReadNodesFromFile(Ss, Separator, Graph, NColId, IntAttrNVals, FltAttrNVals, StrAttrNVals);
    } else if (EDGES_START == Ss.GetFld(0)) {
      // Map edge attribute names to column number in the file.
      TStrIntH IntAttrEVals;
      TStrIntH FltAttrEVals;
      TStrIntH StrAttrEVals;
      int SrcColId = -1;
      int DstColId = -1;
      ReadEdgeSchemaFromFile(Ss, Separator, SrcColId, DstColId, IntAttrEVals, FltAttrEVals, StrAttrEVals);
      isSchemaLine = ReadEdgesFromFile(Ss, Separator, Graph, SrcColId, DstColId, IntAttrEVals, FltAttrEVals, StrAttrEVals);
    }
  }

  return Graph;
}

template<class PGraph >

PGraph TSnap::LoadEdgeListStr	(	const TStr &	InFNm,
		const int &	SrcColId,
		const int &	DstColId
	)

Loads a (directed, undirected or multi) graph from a text file InFNm with 1 edge per line (whitespace separated columns, arbitrary string node ids).

Loads the format saved by TSnap::SaveEdgeList(), where node IDs are strings.

Whitespace separated file of several columns: ... <source node="" id>=""> ... <destination node="" id>=""> ... SrcColId and DstColId are column indexes of source/destination (string) node ids. This means there is one edge per line and node IDs can be arbitrary STRINGs. Note that the mapping of node names to ids is discarded.

Definition at line 126 of file gio.h.

                                                                                    {
  TSsParser Ss(InFNm, ssfWhiteSep);
  PGraph Graph = PGraph::TObj::New();
  TStrHash<TInt> StrToNIdH(Mega(1), true); // hash-table mapping strings to integer node ids
  while (Ss.Next()) {
    const int SrcNId = StrToNIdH.AddKey(Ss[SrcColId]);
    const int DstNId = StrToNIdH.AddKey(Ss[DstColId]);
    if (! Graph->IsNode(SrcNId)) { Graph->AddNode(SrcNId); }
    if (! Graph->IsNode(DstNId)) { Graph->AddNode(DstNId); }
    Graph->AddEdge(SrcNId, DstNId);
  }
  Graph->Defrag();
  return Graph;
}

template<class PGraph >

PGraph TSnap::LoadEdgeListStr	(	const TStr &	InFNm,
		const int &	SrcColId,
		const int &	DstColId,
		TStrHash< TInt > &	StrToNIdH
	)

Loads a (directed, undirected or multi) graph from a text file InFNm with 1 edge per line (whitespace separated columns, arbitrary string node ids).

Loads the format saved by TSnap::SaveEdgeList(), where node IDs are strings and mapping of strings to node ids are stored.

Whitespace separated file of several columns: ... <source node="" id>=""> ... <destination node="" id>=""> ... SrcColId and DstColId are column indexes of source/destination (string) node ids. This means there is one edge per line and node IDs can be arbitrary STRINGs. The mapping of strings to node ids is stored in StrToNIdH. To map between node names and ids use: NId = StrToNIdH.GetKeyId(NodeName) and TStr NodeName = StrToNIdH.GetKey(NId);

Definition at line 149 of file gio.h.

                                                                                                               {
  TSsParser Ss(InFNm, ssfWhiteSep);
  PGraph Graph = PGraph::TObj::New();
  while (Ss.Next()) {
    const int SrcNId = StrToNIdH.AddKey(Ss[SrcColId]);
    const int DstNId = StrToNIdH.AddKey(Ss[DstColId]);
    if (! Graph->IsNode(SrcNId)) { Graph->AddNode(SrcNId); }
    if (! Graph->IsNode(DstNId)) { Graph->AddNode(DstNId); }
    Graph->AddEdge(SrcNId, DstNId);
  }
  Graph->Defrag();
  return Graph;
}

int TSnap::LoadMode	(	TModeNet &	Graph,
		PTable	Table,
		const TStr &	NCol,
		TStrV &	NodeAttrV
	)

Loads the nodes specified in column NCol from the TTable with the attributes specified in NodeAttrV.

Definition at line 14 of file conv.cpp.

                    {

  const TAttrType NodeType = Table->GetColType(NCol);
  const TInt NColIdx = Table->GetColIdx(NCol);

  for (int CurrRowIdx = 0; CurrRowIdx < (Table->Next).Len(); CurrRowIdx++) {
    if ((Table->Next)[CurrRowIdx] == Table->Invalid) {
      continue;
    }

    // add src and dst nodes to graph if they are not seen earlier
    TInt NVal;
    if (NodeType == atFlt) {
      return -1;
    } else if (NodeType == atInt || NodeType == atStr) {
      if (NodeType == atInt) {
        NVal = (Table->IntCols)[NColIdx][CurrRowIdx];
      } else {
        NVal = (Table->StrColMaps)[NColIdx][CurrRowIdx];
        if (strlen(Table->GetContextKey(NVal)) == 0) { continue; }  //illegal value
      }
      if (!Graph.IsNode(NVal)) {Graph.AddNode(NVal); }
    }

    // Aggregate edge attributes and add to graph
    for (TInt i = 0; i < NodeAttrV.Len(); i++) {
      TStr ColName = NodeAttrV[i];
      TAttrType T = Table->GetColType(ColName);
      TInt Index = Table->GetColIdx(ColName);
      switch (T) {
        case atInt:
          Graph.AddIntAttrDatN(NVal, Table->IntCols[Index][CurrRowIdx], ColName);
          break;
        case atFlt:
          Graph.AddFltAttrDatN(NVal, Table->FltCols[Index][CurrRowIdx], ColName);
          break;
        case atStr:
          Graph.AddStrAttrDatN(NVal, Table->GetStrValIdx(Index, CurrRowIdx), ColName);
          break;
      }
    }
  }
  return 1;
}

int TSnap::LoadModeNetToNet	(	PMMNet	Graph,
		const TStr &	Name,
		PTable	Table,
		const TStr &	NCol,
		TStrV &	NodeAttrV
	)

Loads a mode, with name Name, into the PMMNet from the TTable. NCol specifies the node id column and NodeAttrV the node attributes.

Definition at line 6 of file conv.cpp.

                    {
  Graph->AddModeNet(Name);
  TModeNet& Net = Graph->GetModeNetByName(Name);
  return LoadMode(Net, Table, NCol, NodeAttrV);
}

TIntH TSnap::LoadNodeList

(

TStr

InFNmNodes

)

Definition at line 671 of file centr.cpp.

                                   {
  TSsParser Ss(InFNmNodes, ssfWhiteSep, true, true, true);
  TIntIntH Nodes;
  int br = 0, NId;
  while (Ss.Next()) {
    if (Ss.GetInt(0, NId)) { 
    Nodes.AddDat(br,NId);
    br++;
  }
  }
  return Nodes;
}

template<class PGraph >

PGraph TSnap::LoadPajek

(

const TStr &

InFNm

)

Loads a (directed, undirected or multi) graph from Pajek .PAJ format file.

Function supports both the 1 edge per line (<source> <destination> <weight>) as well as the 1 node per line (<source> <destination1> <destination2> ...) formats.

Definition at line 210 of file gio.h.

                                    {
  PGraph Graph = PGraph::TObj::New();
  TSsParser Ss(InFNm, ssfSpaceSep, true, true, true);
  while ((Ss.Len()==0 || strstr(Ss[0], "*vertices") == NULL) && ! Ss.Eof()) {
    Ss.Next();  Ss.ToLc(); }
  // nodes
  bool EdgeList = true;
  EAssert(strstr(Ss[0], "*vertices") != NULL);
  while (Ss.Next()) {
    Ss.ToLc();
    if (Ss.Len()>0 && Ss[0][0] == '%') { continue; } // comment
    if (strstr(Ss[0], "*arcslist")!=NULL || strstr(Ss[0],"*edgeslist")!=NULL) { EdgeList=false; break; } 
    if (strstr(Ss[0], "*arcs")!=NULL || strstr(Ss[0],"*edges")!=NULL) { break; } // arcs are directed, edges are undirected
    Graph->AddNode(Ss.GetInt(0));
  }
  // edges
  while (Ss.Next()) {
    if (Ss.Len()>0 && Ss[0][0] == '%') { continue; } // comment
    if (Ss.Len()>0 && Ss[0][0] == '*') { break; }
    if (EdgeList) {
      // <source> <destination> [ <weight> ]
      if (Ss.Len() >= 2 && Ss.IsInt(0) && Ss.IsInt(1)) {
        Graph->AddEdge(Ss.GetInt(0), Ss.GetInt(1));
      }
    } else {
      // <source> <destination1> <destination2> <destination3> ...
      const int SrcNId = Ss.GetInt(0);
      for (int i = 1; i < Ss.Len(); i++) {
        Graph->AddEdge(SrcNId, Ss.GetInt(i)); }
    }
  }
  return Graph;
}

template<class PGraph >

void TSnap::MakeUnDir

(

const PGraph &

Graph

)

Makes the graph undirected. For every edge (u,v) an edge (v,u) is added (if it does not yet exist).

Definition at line 353 of file alg.h.

                                    {
  CAssert(HasGraphFlag(typename PGraph::TObj, gfDirected)); // graph has to be directed
  TIntPrV EdgeV;
  for (typename PGraph::TObj::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
    const int SrcNId = EI.GetSrcNId();
    const int DstNId = EI.GetDstNId();
    if (! Graph->IsEdge(DstNId, SrcNId)) {
      EdgeV.Add(TIntPr(DstNId, SrcNId));
    }
  }
  for (int i = 0; i < EdgeV.Len(); i++) {
    Graph->AddEdge(EdgeV[i].Val1, EdgeV[i].Val2);
  }
}

template<class PGraph >

void TSnap::MapHits	(	const TVec< PGraph > &	GraphSeq,
		TVec< PTable > &	TableSeq,
		TTableContext *	Context,
		const int &	MaxIter
	)

Gets sequence of Hits tables from given GraphSeq into TableSeq.

Definition at line 636 of file centr.h.

                        {
  int NumGraphs = GraphSeq.Len();
  TableSeq.Reserve(NumGraphs, NumGraphs);
  // This loop is parallelizable.
  for (TInt i = 0; i < NumGraphs; i++) {
    TIntFltH HubH;
    TIntFltH AuthH;
    GetHits(GraphSeq[i], HubH, AuthH, MaxIter);
    PTable HubT =  TTable::TableFromHashMap(HubH, "NodeId", "Hub", Context, false);
    PTable AuthT =  TTable::TableFromHashMap(AuthH, "NodeId", "Authority", Context, false);
    PTable HitsT = HubT->Join("NodeId", AuthT, "NodeId");
    HitsT->Rename("1.NodeId", "NodeId");
    HitsT->Rename("1.Hub", "Hub");
    HitsT->Rename("2.Authority", "Authority");
    TStrV V = TStrV(3, 0);
    V.Add("NodeId");
    V.Add("Hub");
    V.Add("Authority");
    HitsT->ProjectInPlace(V);
    TableSeq[i] = HitsT;
  }
}

template<class PGraph >

void TSnap::MapPageRank	(	const TVec< PGraph > &	GraphSeq,
		TVec< PTable > &	TableSeq,
		TTableContext *	Context,
		const double &	C,
		const double &	Eps,
		const int &	MaxIter
	)

Gets sequence of PageRank tables from given GraphSeq into TableSeq.

Definition at line 621 of file centr.h.

                                                            {
  int NumGraphs = GraphSeq.Len();
  TableSeq.Reserve(NumGraphs, NumGraphs);
  // This loop is parallelizable.
  for (TInt i = 0; i < NumGraphs; i++) {
    TIntFltH PRankH;
    GetPageRank(GraphSeq[i], PRankH, C, Eps, MaxIter);
    TableSeq[i] = TTable::TableFromHashMap(PRankH, "NodeId", "PageRank", Context, false);
  }
}

TIntH TSnap::MaxCPGreedyBetter	(	const PUNGraph &	Graph,
		const int	k
	)

Returns centrality Maximum k group.

Definition at line 175 of file centr.cpp.

                                                            {
  TIntH GroupNodes; // buildup cpntainer of group nodes
  TIntH NNodes; // container of neighbouring nodes
  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);
      if (gc>gc0) {
        gc0 = gc;
        addId = NI.GetKey();
      }
    }
  
    if (addId != addIdPrev){

      GroupNodes.AddDat(br,addId);
      br++;
      gc0=0;

      NNodes.AddDat(addId,0);
      for (int i=0; i<Graph->GetNI(addId).GetDeg(); i++) {
        NNodes.AddDat(Graph->GetNI(addId).GetNbrNId(i),0);
      }
      addIdPrev = addId;
      Nodes.DelKey(addId);
    } else {
      br = k;
    }
    printf("%i,",br);
  }

  // gcFinal = GetGroupDegreeCentr(Graph, GroupNodes);
  return GroupNodes;
}

TIntH TSnap::MaxCPGreedyBetter1	(	const PUNGraph &	Graph,
		const int	k
	)

Returns centrality Maximum k group.

Definition at line 223 of file centr.cpp.

                                                             {
  TIntH GroupNodes;
  TIntH NNodes;
  TIntH Nodes;
  double gc = 0, gc0 = 0;
  int addId = 0, addIdPrev = 0;
  
  // put nodes in the container and sort them by vertex degree
  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);
      if (gc>gc0) {
        gc0 = gc;
        addId = NI.GetKey();
      }
    }
  
    if (addId != addIdPrev){

      GroupNodes.AddDat(br,addId);
      br++;
      gc0=-10000000;
  
      NNodes.AddDat(addId,0);
      for (int i=0; i<Graph->GetNI(addId).GetDeg(); i++) {
        NNodes.AddDat(Graph->GetNI(addId).GetNbrNId(i),0);
      }
      addIdPrev = addId;
      Nodes.DelKey(addId);
    }
  }

  // gcFinal = GetGroupDegreeCentr(Graph, GroupNodes);
  return GroupNodes;
}

TIntH TSnap::MaxCPGreedyBetter2	(	const PUNGraph &	Graph,
		const int	k
	)

Returns centrality Maximum k group.

Definition at line 268 of file centr.cpp.

                                                             {
  TIntH GroupNodes; // buildup cpntainer of group nodes
  TStr NNodes; // container of neighbouring nodes
  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);
      if (gc>gc0) {
        gc0 = gc;
        addId = NI.GetKey();
      }
    }
  
    if (addId != addIdPrev) {

      GroupNodes.AddDat(br,addId);
      br++;
      gc0=0;
    
      TInt digi = addId;
      TStr buf = digi.GetStr();

      NNodes += " "+buf;

      for (int i=0; i<Graph->GetNI(addId).GetDeg(); i++) {
        TInt digi = Graph->GetNI(addId).GetNbrNId(i);
        TStr buf = digi.GetStr();
        NNodes += " "+buf;
      }
      addIdPrev = addId;
      Nodes.DelKey(addId);
    } else {
      br = k;
    }
    printf("%i,",br);
  }

  // gcFinal = GetGroupDegreeCentr(Graph, GroupNodes);
  return GroupNodes;
}

TIntH TSnap::MaxCPGreedyBetter3	(	const PUNGraph &	Graph,
		const int	k
	)

Returns centrality Maximum k group.

Definition at line 322 of file centr.cpp.

                                                             {
  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;
  // gcFinal = GetGroupDegreeCentr(Graph, GroupNodes);
  return GroupNodes;
}

template<class PGraph >

void TSnap::MergeNbrs	(	TIntV &	NeighbourV,
		const typename PGraph::TObj::TNodeI &	NI
	)

Merges neighbors by removing duplicates and produces one sorted vector of neighbors.

Definition at line 526 of file triad.h.

                                                                       {
  int j = 0;
  int k = 0;
  int prev = -1;
  int indeg = NI.GetInDeg();
  int outdeg = NI.GetOutDeg();
  if (indeg > 0  &&  outdeg > 0) {
    int v1 = NI.GetInNId(j);
    int v2 = NI.GetOutNId(k);
    while (1) {
      if (v1 <= v2) {
        if (prev != v1) {
          NeighbourV.Add(v1);
          prev = v1;
        }
        j += 1;
        if (j >= indeg) {
          break;
        }
        v1 = NI.GetInNId(j);
      } else {
        if (prev != v2) {
          NeighbourV.Add(v2);
          prev = v2;
        }
        k += 1;
        if (k >= outdeg) {
          break;
        }
        v2 = NI.GetOutNId(k);
      }
    }
  }
  while (j < indeg) {
    int v = NI.GetInNId(j);
    if (prev != v) {
      NeighbourV.Add(v);
      prev = v;
    }
    j += 1;
  }
  while (k < outdeg) {
    int v = NI.GetOutNId(k);
    if (prev != v) {
      NeighbourV.Add(v);
      prev = v;
    }
    k += 1;
  }
}

void TSnap::NumpyToTFltV	(	TFltV &	FltV,
		float *	FltNumpyVecIn,
		int	n
	)

Converts NumpyArray to TFltV.

Fills the FltV with Numpy Array values. Assumes that the vector is of size n.

Definition at line 33 of file numpy.cpp.

                                                            {
                for (int i = 0; i < n; ++i) {
                                FltV[i] = FltNumpyVecIn[i];
                }
}

void TSnap::NumpyToTIntV	(	TIntV &	IntV,
		int *	IntNumpyVecIn,
		int	n
	)

Converts NumpyArray to TIntV.

Fills the IntV with Numpy Array values. Assumes that IntV is of size n.

Definition at line 25 of file numpy.cpp.

                                                          {
                for (int i = 0; i < n; ++i) {
                                IntV[i] = IntNumpyVecIn[i];
                }
}

double TSnap::PearsonCorrelation	(	PUNGraph &	Graph,
		TIntIntH &	out,
		int	coresize
	)

Definition at line 205 of file coreper.cpp.

                                                                         {
    int br_core1=0,br_periphery1=0,br_core_per1=0;
    for (TUNGraph::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++){ // Calculate and store the degrees of each node.
      int i = EI.GetSrcNId();
      int j = EI.GetDstNId();
      
      if (out.GetDat(i)==1&&out.GetDat(j)==1 && i!=j)
        br_core1++;
      else if (out.GetDat(i)==0&&out.GetDat(j)==0 && i!=j)
        br_periphery1++;
      else
        br_core_per1++;
    }

    double core_quality = (double)br_core1/((((double)coresize*(double)coresize)-(double)coresize)/2);
    int per_size = Graph->GetNodes()-coresize;
    double periphery_quality = (((((double)per_size*(double)per_size)-(double)per_size)/2) - (double)br_periphery1)/((((double)per_size*(double)per_size)-(double)per_size)/2);

    return (double)(core_quality+periphery_quality);
  }

template<class PGraph >

void TSnap::PlotClustCf	(	const PGraph &	Graph,
		const TStr &	FNmPref,
		TStr	DescStr = TStr()
	)

Plots the distribution of clustering coefficient of a Graph.

Definition at line 111 of file statplot.h.

                                                                         {
  TFltPrV DegToCCfV;
  int64 ClosedTriads, OpenTriads;
  const double CCF = GetClustCf(Graph, DegToCCfV, ClosedTriads, OpenTriads);
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGnuPlot GnuPlot("ccf."+FNmPref,
    TStr::Fmt("%s. G(%d, %d). Average clustering: %.4f  OpenTriads: %d (%.4f)  ClosedTriads: %d (%.4f)", DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges(),
    CCF, OpenTriads, OpenTriads/double(OpenTriads+ClosedTriads), ClosedTriads, ClosedTriads/double(OpenTriads+ClosedTriads)));
  GnuPlot.AddPlot(DegToCCfV, gpwLinesPoints, "", "pt 6");
  GnuPlot.SetXYLabel("Node degree", "Average clustering coefficient");
  GnuPlot.SetScale(gpsLog10XY);
  GnuPlot.SavePng();
}

void TSnap::PlotEigValDistr	(	const PUNGraph &	Graph,
		const int &	EigVals,
		const TStr &	FNmPref,
		TStr	DescStr
	)

Plots the distribution of components of the leading eigen-vector of the Graph adjacency matrix. Plots first EigVals values.

Definition at line 14 of file statplot.cpp.

                                                                                                   {
  const int NBuckets = 50;
  TFltV EigValV;
  for (int f = 1; EigValV.Empty() && f < 4; f++) {
    TSnap::GetEigVals(Graph, f*EigVals, EigValV);
  }
  EigValV.Sort(true);
  THash<TFlt, TFlt> BucketCntH;
  double Step = (EigValV.Last()-EigValV[0]) / double(NBuckets-1);
  for (int i = 0; i < NBuckets; i++) {
    BucketCntH.AddDat(EigValV[0]+Step*(i+0.5), 0);
  }
  for (int i = 0; i < EigValV.Len(); i++) {
    const int Bucket = (int) floor((EigValV[i]-EigValV[0]) / Step);
    BucketCntH[Bucket] += 1;
  }
  TFltPrV EigCntV;
  BucketCntH.GetKeyDatPrV(EigCntV);
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGnuPlot::PlotValV(EigCntV, "eigDistr."+FNmPref, TStr::Fmt("%s. G(%d, %d). Largest eig val = %f", DescStr.CStr(),
    Graph->GetNodes(), Graph->GetEdges(), EigValV.Last().Val), "Eigen value", "Count", gpsAuto, false, gpwLinesPoints);
}

void TSnap::PlotEigValRank	(	const PUNGraph &	Graph,
		const int &	EigVals,
		const TStr &	FNmPref,
		TStr	DescStr
	)

Plots the eigen-value rank distribution of the Graph adjacency matrix. Plots first EigVals eigenvalues.

Definition at line 5 of file statplot.cpp.

                                                                                                  {
  TFltV EigValV;
  TSnap::GetEigVals(Graph, EigVals, EigValV);
  EigValV.Sort(false);
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGnuPlot::PlotValV(EigValV, "eigVal."+FNmPref, TStr::Fmt("%s. G(%d, %d). Largest eig val = %f",
    DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges(), EigValV[0].Val), "Rank", "Eigen value", gpsLog10XY, false, gpwLinesPoints);
}

template<class PGraph >

void TSnap::PlotHops	(	const PGraph &	Graph,
		const TStr &	FNmPref,
		TStr	DescStr = TStr(),
		const bool &	IsDir = false,
		const int &	NApprox = 32
	)

Plots the cumulative distribution of the shortest path lengths of a Graph. Implementation is based on ANF.

Parameters

IsDir

false: ignore edge directions and consider graph as undirected.

Definition at line 126 of file statplot.h.

                                                                                                             {
  TIntFltKdV DistNbrsV;
  TSnap::GetAnf(Graph, DistNbrsV, -1, IsDir, NApprox);
  const double EffDiam = TSnap::TSnapDetail::CalcEffDiam(DistNbrsV, 0.9);
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGnuPlot GnuPlot("hop."+FNmPref, TStr::Fmt("%s. Hop plot. EffDiam: %g, G(%d, %d)",
    DescStr.CStr(), EffDiam, Graph->GetNodes(), Graph->GetEdges()));
  GnuPlot.SetXYLabel("Number of hops", "Number of pairs of nodes");
  GnuPlot.SetScale(gpsLog10Y);
  GnuPlot.AddPlot(DistNbrsV, gpwLinesPoints, "", "pt 6");
  GnuPlot.SavePng();
}

template<class PGraph >

void TSnap::PlotInDegDistr	(	const PGraph &	Graph,
		const TStr &	FNmPref,
		TStr	DescStr = TStr(),
		const bool &	PlotCCdf = false,
		const bool &	PowerFit = false
	)

Plots the in-degree distribution of a Graph.

Parameters

PlotCCdf	Plots the distribution as a Complementary Cummulative distribution function.
PowerFit	Fits a Power-Law to the distribution.

Definition at line 47 of file statplot.h.

                                                                                                                        {
  TIntPrV DegCntV;
  TSnap::GetInDegCnt(Graph, DegCntV);
  const double AvgDeg = 2*Graph->GetEdges()/double(Graph->GetNodes());
  int AboveAvg=0, Above2Avg=0;
  for (int i = 0; i < DegCntV.Len(); i++) {
    if (DegCntV[i].Val1 > AvgDeg) { AboveAvg += DegCntV[i].Val2; }
    if (DegCntV[i].Val1 > 2*AvgDeg) { Above2Avg += DegCntV[i].Val2; }
  }
  if (PlotCCdf) {
    DegCntV = TGUtil::GetCCdf(DegCntV); }
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGnuPlot::PlotValV(DegCntV, (PlotCCdf?"inDegC.":"inDeg.")+FNmPref,
    TStr::Fmt("%s. G(%d, %d). %d (%.4f) nodes with in-deg > avg deg (%.1f), %d (%.4f) with >2*avg.deg", DescStr.CStr(),
      Graph->GetNodes(), Graph->GetEdges(), AboveAvg, AboveAvg/double(Graph->GetNodes()), AvgDeg, Above2Avg, Above2Avg/double(Graph->GetNodes())),
    "In-degree", PlotCCdf?"Count (CCDF)":"Count", gpsLog10XY, PowerFit, gpwLinesPoints);
}

void TSnap::PlotInvParticipRat	(	const PUNGraph &	Graph,
		const int &	MaxEigVecs,
		const int &	TimeLimit,
		const TStr &	FNmPref,
		TStr	DescStr = TStr()
	)

Plots the inverse participation ratio. See Spectra of "real-world" graphs: Beyond the semicircle law by Farkas, Derenyi, Barabasi and Vicsek.

Definition at line 39 of file statplot.cpp.

                                                                                                                               {
  TFltPrV EigIprV;
  GetInvParticipRat(Graph, MaxEigVecs, TimeLimit, EigIprV);
  if (DescStr.Empty()) { DescStr = FNmPref; }
  if (EigIprV.Empty()) { DescStr+=". FAIL"; EigIprV.Add(TFltPr(-1,-1)); return; }
  TGnuPlot::PlotValV(EigIprV, "eigIPR."+FNmPref, TStr::Fmt("%s. G(%d, %d). Largest eig val = %f (%d values)",
    DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges(), EigIprV.Last().Val1(), EigIprV.Len()),
    "Eigenvalue", "Inverse Participation Ratio of corresponding Eigenvector", gpsLog10Y, false, gpwPoints);
}

template<class PGraph >

void TSnap::PlotKCoreEdges	(	const PGraph &	Graph,
		const TStr &	FNmPref,
		TStr	DescStr = TStr()
	)

Plots the k-Core edge-size distribution: Core k vs. number of edges in k-core.

Definition at line 175 of file statplot.h.

                                                                            {
  TIntPrV CoreEdgesV;
  TSnap::GetKCoreEdges(Graph, CoreEdgesV);
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGnuPlot::PlotValV(CoreEdgesV, "coreEdges."+FNmPref, TStr::Fmt("%s. G(%d, %d).", DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges()), "k-Core", "Number of edges in the k-Core", gpsLog10Y, false, gpwLinesPoints);
}

template<class PGraph >

void TSnap::PlotKCoreNodes	(	const PGraph &	Graph,
		const TStr &	FNmPref,
		TStr	DescStr = TStr()
	)

Plots the k-Core node-size distribution: Core k vs. number of nodes in k-core.

Definition at line 167 of file statplot.h.

                                                                            {
  TIntPrV CoreNodesV;
  TSnap::GetKCoreNodes(Graph, CoreNodesV);
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGnuPlot::PlotValV(CoreNodesV, "coreNodes."+FNmPref, TStr::Fmt("%s. G(%d, %d).", DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges()), "k-Core", "Number of nodes in the k-Core", gpsLog10Y, false, gpwLinesPoints);
}

template<class PGraph >

void TSnap::PlotOutDegDistr	(	const PGraph &	Graph,
		const TStr &	FNmPref,
		TStr	DescStr = TStr(),
		const bool &	PlotCCdf = false,
		const bool &	PowerFit = false
	)

Plots the out-degree distribution of a Graph.

Parameters

PlotCCdf	Plots the distribution as a Complementary Cumulative Distribution Function (CCDF).
PowerFit	Fits a Power-Law to the distribution.

Definition at line 66 of file statplot.h.

                                                                                                                         {
  TIntPrV DegCntV;
  TSnap::GetOutDegCnt(Graph, DegCntV);
  const double AvgDeg = 2*Graph->GetEdges()/double(Graph->GetNodes());
  int AboveAvg=0, Above2Avg=0;
  for (int i = 0; i < DegCntV.Len(); i++) {
    if (DegCntV[i].Val1 > AvgDeg) { AboveAvg += DegCntV[i].Val2; }
    if (DegCntV[i].Val1 > 2*AvgDeg) { Above2Avg += DegCntV[i].Val2; }
  }
  if (PlotCCdf) {
    DegCntV = TGUtil::GetCCdf(DegCntV); }
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGnuPlot::PlotValV(DegCntV, (PlotCCdf?"outDegC.":"outDeg.")+FNmPref,
    TStr::Fmt("%s. G(%d, %d). %d (%.4f) nodes with out-deg > avg deg (%.1f), %d (%.4f) with >2*avg.deg", DescStr.CStr(),
      Graph->GetNodes(), Graph->GetEdges(), AboveAvg, AboveAvg/double(Graph->GetNodes()), AvgDeg, Above2Avg, Above2Avg/double(Graph->GetNodes())),
    "Out-degree", PlotCCdf?"Count (CCDF)":"Count", gpsLog10XY, PowerFit, gpwLinesPoints);
}

template<class PGraph >

void TSnap::PlotSccDistr	(	const PGraph &	Graph,
		const TStr &	FNmPref,
		TStr	DescStr = TStr()
	)

Plots the distribution of sizes of strongly connected components of a Graph.

Definition at line 98 of file statplot.h.

                                                                          {
  TIntPrV SccSzCnt;
  TSnap::GetSccSzCnt(Graph, SccSzCnt);
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGnuPlot GnuPlot("scc."+FNmPref, TStr::Fmt("%s. G(%d, %d). Largest component has %f nodes",
    DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges(), SccSzCnt.Last().Val1/double(Graph->GetNodes())));
  GnuPlot.AddPlot(SccSzCnt, gpwLinesPoints, "", "pt 6");
  GnuPlot.SetXYLabel("Size of strongly connected component", "Number of components");
  GnuPlot.SetScale(gpsLog10XY);
  GnuPlot.SavePng();
}

template<class PGraph >

void TSnap::PlotShortPathDistr	(	const PGraph &	Graph,
		const TStr &	FNmPref,
		TStr	DescStr = TStr(),
		int	TestNodes = TInt::Mx
	)

Plots the distribution of the shortest path lengths of a Graph. Implementation is based on BFS.

Definition at line 140 of file statplot.h.

                                                                                               {
  TIntH DistToCntH;
  TBreathFS<PGraph> BFS(Graph);
  // shotest paths
  TIntV NodeIdV;
  Graph->GetNIdV(NodeIdV);  NodeIdV.Shuffle(TInt::Rnd);
  for (int tries = 0; tries < TMath::Mn(TestNodes, Graph->GetNodes()); tries++) {
    const int NId = NodeIdV[tries];
    BFS.DoBfs(NId, true, false, -1, TInt::Mx);
    for (int i = 0; i < BFS.NIdDistH.Len(); i++) {
      DistToCntH.AddDat(BFS.NIdDistH[i]) += 1; }
  }
  DistToCntH.SortByKey(true);
  TFltPrV DistNbrsPdfV;
  for (int i = 0; i < DistToCntH.Len(); i++) {
    DistNbrsPdfV.Add(TFltPr(DistToCntH.GetKey(i)(), DistToCntH[i]()));
  }
  const double EffDiam = TSnap::TSnapDetail::CalcEffDiamPdf(DistNbrsPdfV, 0.9);
  const double AvgDiam = TSnap::TSnapDetail::CalcAvgDiamPdf(DistNbrsPdfV);
  const int FullDiam = (int) DistNbrsPdfV.Last().Val1;
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGnuPlot::PlotValV(DistNbrsPdfV, "diam."+FNmPref,
    TStr::Fmt("%s. G(%d, %d). Diam: avg:%.2f  eff:%.2f  max:%d", DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges(),
    AvgDiam, EffDiam, FullDiam), "Number of hops", "Number of shortest paths", gpsLog10Y, false, gpwLinesPoints);
}

void TSnap::PlotSngValDistr	(	const PNGraph &	Graph,
		const int &	SngVals,
		const TStr &	FNmPref,
		TStr	DescStr
	)

Plots the rank distribution of singular values of the Graph adjacency matrix. Plots first SngVals values.

Definition at line 58 of file statplot.cpp.

                                                                                                  {
  const int NBuckets = 50;
  TFltV SngValV;
  for (int f = 1; SngValV.Empty() && f < 4; f++) {
    TSnap::GetSngVals(Graph, f*SngVals, SngValV);
  }
  SngValV.Sort(true);
  THash<TFlt, TFlt> BucketCntH;
  double Step = (SngValV.Last()-SngValV[0]) / double(NBuckets-1);
  for (int i = 0; i < NBuckets; i++) {
    BucketCntH.AddDat(SngValV[0]+Step*(i+0.5), 0);
  }
  for (int i = 0; i < SngValV.Len(); i++) {
    const int Bucket = (int) floor((SngValV[i]-SngValV[0]) / Step);
    BucketCntH[Bucket] += 1;
  }
  TFltPrV EigCntV;
  BucketCntH.GetKeyDatPrV(EigCntV);
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGnuPlot::PlotValV(EigCntV, "sngDistr."+FNmPref, TStr::Fmt("%s. G(%d, %d). Largest eig val = %f", DescStr.CStr(),
    Graph->GetNodes(), Graph->GetEdges(), SngValV.Last().Val), "Singular value", "Count", gpsAuto, false, gpwLinesPoints);
}

void TSnap::PlotSngValRank	(	const PNGraph &	Graph,
		const int &	SngVals,
		const TStr &	FNmPref,
		TStr	DescStr
	)

Plots the rank distribution of singular values of the Graph adjacency matrix. Plots first SngVals values.

Definition at line 49 of file statplot.cpp.

                                                                                                 {
  TFltV SngValV;
  TSnap::GetSngVals(Graph, SngVals, SngValV);
  SngValV.Sort(false);
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGnuPlot::PlotValV(SngValV, "sngVal."+FNmPref, TStr::Fmt("%s. G(%d, %d). Largest eig val = %f",
    DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges(), SngValV[0].Val), "Rank", "Singular value", gpsLog10XY, false, gpwLinesPoints);
}

void TSnap::PlotSngVec	(	const PNGraph &	Graph,
		const TStr &	FNmPref,
		TStr	DescStr
	)

Plots the distribution of the values of the leading left singular vector of the Graph adjacency matrix. Plots first SngVals values.

Definition at line 81 of file statplot.cpp.

                                                                         {
  TFltV LeftSV, RightSV;
  TSnap::GetSngVec(Graph, LeftSV, RightSV);
  LeftSV.Sort(false);
  RightSV.Sort(false);
  TFltV BinV;
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGUtil::MakeExpBins(LeftSV, BinV, 1.01);
  TGnuPlot::PlotValV(BinV, "sngVecL."+FNmPref, TStr::Fmt("%s. G(%d, %d). Left signular vector",
    DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges()), "Rank", "Component of left singular vector", gpsLog10XY, false, gpwLinesPoints);
  TGnuPlot::PlotValV(BinV, "sngVecL."+FNmPref, TStr::Fmt("%s. G(%d, %d). Right signular vector",
    DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges()), "Rank", "Component of right singular vector", gpsLog10XY, false, gpwLinesPoints);
}

template<class PGraph >

void TSnap::PlotWccDistr	(	const PGraph &	Graph,
		const TStr &	FNmPref,
		TStr	DescStr = TStr()
	)

Plots the distribution of sizes of weakly connected components of a Graph.

Definition at line 85 of file statplot.h.

                                                                          {
  TIntPrV WccSzCnt;
  TSnap::GetWccSzCnt(Graph, WccSzCnt);
  if (DescStr.Empty()) { DescStr = FNmPref; }
  TGnuPlot GnuPlot("wcc."+FNmPref, TStr::Fmt("%s. G(%d, %d). Largest component has %f nodes",
    DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges(), WccSzCnt.Last().Val1/double(Graph->GetNodes())));
  GnuPlot.AddPlot(WccSzCnt, gpwLinesPoints, "", "pt 6");
  GnuPlot.SetXYLabel("Size of weakly connected component", "Number of components");
  GnuPlot.SetScale(gpsLog10XY);
  GnuPlot.SavePng();
}

template<class PGraph >

void TSnap::PrintInfo	(	const PGraph &	Graph,
		const TStr &	Desc = "",
		const TStr &	OutFNm = "",
		const bool &	Fast = true
	)

Prints basic graph statistics.

Parameters

Fast	true: only computes basic statistics (that can be computed fast). For more extensive information (and longer execution times) set Fast = false.

Definition at line 87 of file gbase.h.

                                                                                            {
  int BiDirEdges=0, ZeroNodes=0, ZeroInNodes=0, ZeroOutNodes=0, SelfEdges=0, NonZIODegNodes=0;
  THash<TIntPr, TInt> UniqDirE, UniqUnDirE;
  FILE *F = stdout;
  if (! OutFNm.Empty()) F = fopen(OutFNm.CStr(), "wt");
  if (! Desc.Empty()) { fprintf(F, "%s:", Desc.CStr()); }
  else { fprintf(F, "Graph:"); }
  for (int f = gfUndef; f < gfMx; f++) {
    if (HasGraphFlag(typename PGraph::TObj, TGraphFlag(f))) {
      fprintf(F, " %s", TSnap::GetFlagStr(TGraphFlag(f)).CStr()); }
  }
  // calc stat
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NI.GetDeg()==0) ZeroNodes++;
    if (NI.GetInDeg()==0) ZeroInNodes++;
    if (NI.GetOutDeg()==0) ZeroOutNodes++;
    if (NI.GetInDeg()!=0 && NI.GetOutDeg()!=0) NonZIODegNodes++;
    if (! Fast || Graph->GetNodes() < 1000) {
      const int NId = NI.GetId();
      for (int edge = 0; edge < NI.GetOutDeg(); edge++) {
        const int DstNId = NI.GetOutNId(edge);
        if (Graph->IsEdge(DstNId, NId)) BiDirEdges++;
        if (NId == DstNId) SelfEdges++;
        UniqDirE.AddKey(TIntPr(NId, DstNId));
        UniqUnDirE.AddKey(TIntPr(TInt::GetMn(NId, DstNId), TInt::GetMx(NId, DstNId)));
      }
    }
  }
  int64 Closed=0, Open=0;
  double WccSz=0, SccSz=0;
  double EffDiam=0;
  int FullDiam=0;
  if (! Fast) {
    TSnap::GetTriads(Graph, Closed, Open);
    WccSz = TSnap::GetMxWccSz(Graph);
    SccSz = TSnap::GetMxSccSz(Graph);
    TSnap::GetBfsEffDiam(Graph, 100, false, EffDiam, FullDiam);
  }
  // print info
  fprintf(F, "\n");
  fprintf(F, "  Nodes:                    %d\n", Graph->GetNodes());
  fprintf(F, "  Edges:                    %d\n", Graph->GetEdges());
  fprintf(F, "  Zero Deg Nodes:           %d\n", ZeroNodes);
  fprintf(F, "  Zero InDeg Nodes:         %d\n", ZeroInNodes);
  fprintf(F, "  Zero OutDeg Nodes:        %d\n", ZeroOutNodes);
  fprintf(F, "  NonZero In-Out Deg Nodes: %d\n", NonZIODegNodes);
  if (! Fast) {
    fprintf(F, "  Unique directed edges:    %d\n", UniqDirE.Len());
    fprintf(F, "  Unique undirected edges:  %d\n", UniqUnDirE.Len());
    fprintf(F, "  Self Edges:               %d\n", SelfEdges);
    fprintf(F, "  BiDir Edges:              %d\n", BiDirEdges);
    fprintf(F, "  Closed triangles:         %s\n", TUInt64::GetStr(Closed).CStr());
    fprintf(F, "  Open triangles:           %s\n", TUInt64::GetStr(Open).CStr());
    fprintf(F, "  Frac. of closed triads:   %f\n", Closed/double(Closed+Open));
    fprintf(F, "  Connected component size: %f\n", WccSz);
    fprintf(F, "  Strong conn. comp. size:  %f\n", SccSz);
    fprintf(F, "  Approx. full diameter:    %d\n", FullDiam);
    fprintf(F, "  90%% effective diameter:  %f\n", EffDiam);
    //fprintf(F, "  Core\tNodes\tEdges\n");
    //for (int i  = 0; i < CNodesV.Len(); i++) {
    //  printf("  %d\t%d\t%d\n", CNodesV[i].Val1(), CNodesV[i].Val2(), CEdgesV[i].Val2());
    //}
  }
  if (! OutFNm.Empty()) { fclose(F); }
}

int TSnap::PushRelabel	(	TPRManager &	PRM,
		const int &	NId,
		const TNEANet::TNodeI &	NI
	)

Returns the ID of the neighbor that NId pushes to, -1 if no push was made.

Definition at line 328 of file flow.cpp.

                                                                           {
  int EdgeN = PRM.EdgeNum(NId);
  int EId = -1, NbrNId = -1, ResFlow = 0;
  int Cutoff = NI.GetInDeg();
  if (EdgeN < Cutoff) {
    EId = NI.GetInEId(EdgeN);
    NbrNId = NI.GetInNId(EdgeN);
    ResFlow = PRM.Flow(EId);
  } else {
    EId = NI.GetOutEId(EdgeN - Cutoff);
    NbrNId = NI.GetOutNId(EdgeN - Cutoff);
    ResFlow = PRM.Capacity(EId) - PRM.Flow(EId);
  }
  if (ResFlow > 0 && PRM.Label(NId) - 1 == PRM.Label(NbrNId)) {
    if (EdgeN < Cutoff) {
      PushToInNbr(PRM, NId, NbrNId, EId);
    } else {
      PushToOutNbr(PRM, NId, NbrNId, EId);
    }
    return NbrNId;
  }
  if (EdgeN + 1 == NI.GetDeg()) {
    PRM.EdgeNum(NId) = 0;
    Relabel(PRM, NId, NI);
  } else {
    PRM.EdgeNum(NId)++;
  }
  return -1;
}

void TSnap::PushToInNbr	(	TPRManager &	PRM,
		const int &	NId,
		const int &	InNId,
		const int &	EId
	)

Returns flow from a node NId to a neighbor InNId over edge EId.

Definition at line 297 of file flow.cpp.

                                                                                     {
  int MinPush = MIN(PRM.Flow(EId), PRM.Excess(NId));
  PRM.Flow(EId) -= MinPush;
  PRM.Excess(NId) -= MinPush;
  PRM.Excess(InNId) += MinPush;
}

void TSnap::PushToOutNbr	(	TPRManager &	PRM,
		const int &	NId,
		const int &	OutNId,
		const int &	EId
	)

Pushes flow from a node NId to a neighbor OutNId over edge EId.

Definition at line 289 of file flow.cpp.

                                                                                       {
  int MinPush = MIN(PRM.Capacity(EId) - PRM.Flow(EId), PRM.Excess(NId));
  PRM.Flow(EId) += MinPush;
  PRM.Excess(NId) -= MinPush;
  PRM.Excess(OutNId) += MinPush;
}

int TSnap::ReadEdgeSchemaFromFile	(	TSsParser &	Ss,
		const char &	Separator,
		int &	SrcColId,
		int &	DstColId,
		TStrIntH &	IntAttrEVals,
		TStrIntH &	FltAttrEVals,
		TStrIntH &	StrAttrEVals
	)

Definition at line 6 of file gio.cpp.

                                                                                                                                                                       {
  if (EDGES_START != Ss.GetFld(0)) return -1;
  for (int i = 1; i < Ss.GetFlds(); i++) {
    if (SRC_ID_NAME == Ss.GetFld(i)) {
      SrcColId = i-1;
      continue;
    }
    if (DST_ID_NAME == Ss.GetFld(i)) {
      DstColId = i-1;
      continue;
    }
    TStr Attr(Ss.GetFld(i));
    TStr AttrType;
    TStr AttrName;
    Attr.SplitOnCh(AttrType, ':', AttrName);
    if (AttrType == INT_TYPE_PREFIX) {
      IntAttrEVals.AddDat(AttrName, i-1);
    } else if (AttrType == FLT_TYPE_PREFIX) {
      FltAttrEVals.AddDat(AttrName, i-1);
    } else if (AttrType == STR_TYPE_PREFIX) {
      StrAttrEVals.AddDat(AttrName, i-1);
    } else {
      return -1;
    }
  }
  return 0;
}

bool TSnap::ReadEdgesFromFile	(	TSsParser &	Ss,
		const char &	Separator,
		PNEANet &	Graph,
		int &	SrcColId,
		int &	DstColId,
		TStrIntH &	IntAttrEVals,
		TStrIntH &	FltAttrEVals,
		TStrIntH &	StrAttrEVals
	)

Definition at line 38 of file gio.cpp.

                                                                                                                                                                                   {
  int SrcNId, DstNId;
  while (Ss.Next()) {
    if (Ss.GetFlds() == 0) continue;
    if (END_SENTINEL == Ss.GetFld(0)) { return false; }
    if (EDGES_START == Ss.GetFld(0)) { return true; }
    if (NODES_START == Ss.GetFld(0)) { return true; }
    if (Ss.GetFld(0)[0] == '#') { continue; }
    if (! Ss.GetInt(SrcColId, SrcNId) || ! Ss.GetInt(DstColId, DstNId)) { continue; }
    if (! Graph->IsNode(SrcNId)) { Graph->AddNode(SrcNId); }
    if (! Graph->IsNode(DstNId)) { Graph->AddNode(DstNId); }
    int EId = Graph->AddEdge(SrcNId, DstNId);
    double FltAttrVal;
    for (TStrIntH::TIter it = FltAttrEVals.BegI(); it < FltAttrEVals.EndI(); it++) {
      if (Ss.GetFlt(it.GetDat(), FltAttrVal)) {
        Graph->AddFltAttrDatE(EId, FltAttrVal, it.GetKey());
      }
    }
    int IntAttrVal;
    for (TStrIntH::TIter it = IntAttrEVals.BegI(); it < IntAttrEVals.EndI(); it++) {
      if (Ss.GetInt(it.GetDat(), IntAttrVal)) {
        Graph->AddIntAttrDatE(EId, IntAttrVal, it.GetKey());
      }
    }
    char* StrAttrVal;
    for (TStrIntH::TIter it = StrAttrEVals.BegI(); it < StrAttrEVals.EndI(); it++) {
      StrAttrVal = Ss.GetFld(it.GetDat());
      if (NULL_VAL != StrAttrVal) {
        Graph->AddStrAttrDatE(EId, TStr(StrAttrVal), it.GetKey());
      }
    }
  }
  return false;
}

int TSnap::ReadNodeSchemaFromFile	(	TSsParser &	Ss,
		const char &	Separator,
		int &	NId,
		TStrIntH &	IntAttrNVals,
		TStrIntH &	FltAttrNVals,
		TStrIntH &	StrAttrNVals
	)

Definition at line 77 of file gio.cpp.

                                                                                                                                                   {
  if (NODES_START != Ss.GetFld(0)) return -1;
  for (int i = 1; i < Ss.GetFlds(); i++) {
    if (NID_NAME == Ss.GetFld(i)) {
      NId = i-1;
      continue;
    }
    TStr Attr(Ss.GetFld(i));
    TStr AttrType;
    TStr AttrName;
    Attr.SplitOnCh(AttrType, ':', AttrName);
    if (AttrType == INT_TYPE_PREFIX) {
      IntAttrNVals.AddDat(AttrName, i-1);
    } else if (AttrType == FLT_TYPE_PREFIX) {
      FltAttrNVals.AddDat(AttrName, i-1);
    } else if (AttrType == STR_TYPE_PREFIX) {
      StrAttrNVals.AddDat(AttrName, i-1);
    } else {
      return -1;
    }
  }
  return 0;
}

bool TSnap::ReadNodesFromFile	(	TSsParser &	Ss,
		const char &	Separator,
		PNEANet &	Graph,
		int &	NColId,
		TStrIntH &	IntAttrNVals,
		TStrIntH &	FltAttrNVals,
		TStrIntH &	StrAttrNVals
	)

Definition at line 105 of file gio.cpp.

                                                                                                                                                                  {
  int NId;
  while (Ss.Next()) {
    if (Ss.GetFlds() == 0) continue;
    if (END_SENTINEL == Ss.GetFld(0)) { return false; }
    if (EDGES_START == Ss.GetFld(0)) { return true; }
    if (NODES_START == Ss.GetFld(0)) { return true; }
    if (Ss.GetFld(0)[0] == '#') { continue; }
    if (! Ss.GetInt(NColId, NId)) { continue; }
    if (! Graph->IsNode(NId)) { Graph->AddNode(NId); }
    double FltAttrVal;
    for (TStrIntH::TIter it = FltAttrNVals.BegI(); it < FltAttrNVals.EndI(); it++) {
      if (Ss.GetFlt(it.GetDat(), FltAttrVal)) {
        Graph->AddFltAttrDatN(NId, FltAttrVal, it.GetKey());
      }
    }
    int IntAttrVal;
    for (TStrIntH::TIter it = IntAttrNVals.BegI(); it < IntAttrNVals.EndI(); it++) {
      if (Ss.GetInt(it.GetDat(), IntAttrVal)) {
        Graph->AddIntAttrDatN(NId, IntAttrVal, it.GetKey());
      }
    }
    char* StrAttrVal;
    for (TStrIntH::TIter it = StrAttrNVals.BegI(); it < StrAttrNVals.EndI(); it++) {
      StrAttrVal = Ss.GetFld(it.GetDat());
      if (NULL_VAL != StrAttrVal) {
        Graph->AddStrAttrDatN(NId, TStr(StrAttrVal), it.GetKey());
      }
    }
  }
  return false;
}

void TSnap::ReebRefine	(	PNGraph &	Graph,
		TIntH &	t,
		int	e,
		PNGraph &	gFinal,
		TIntH &	tFinal,
		bool	collapse
	)

Definition at line 984 of file cmty.cpp.

                                                                                                {
  TIntIntVH components;
  TIntIntVH ct;

  int newId = 0; //get first new free id;

  // gett first and last t
  int first = 429496729;
  int last = -1;

  // smarter way of determining focus time points
  TIntV timePoints;

  // get first and last time point
  for (THashKeyDatI<TInt, TInt> it = t.BegI(); !it.IsEnd(); it++) {
    if (it.GetDat() < first)
      first = it.GetDat();
    if (it.GetDat() > last)
      last = it.GetDat();
  }

  // adding focus timepoints
  // this can be put in the previous (first, last time point detection) iteration if breaking borders is not an issue
  for (THashKeyDatI<TInt, TInt> it = t.BegI(); !it.IsEnd(); it++) {
    if (it.GetDat() - (e / 2) >= first)
      timePoints.Add(it.GetDat() - (e / 2) /*- 0.1*/);
    timePoints.Add(it.GetDat());
    if (it.GetDat() + (e / 2) <= last)
      timePoints.Add(it.GetDat() + (e / 2) /*+ 0.1*/);
  }

  TIntV timePointsUnique;
  int prevtp = -1;
  //get unique time points
  for (int i = 0; i < timePoints.Len(); i++){
    if (timePoints[i] > prevtp)
      timePointsUnique.Add(timePoints[i]);
    prevtp = timePoints[i];
  }

  timePoints.Clr();
  timePoints = timePointsUnique;

  //iterate each time point
  for (int i = 0; i < timePoints.Len(); i++) {

    int focusTimePoint = timePoints[i];

    TIntV fnodes; // all the nodes int the focus in that step

    // getting nodes in focus -- in epsilon
    for (THashKeyDatI<TInt, TInt> it = t.BegI(); !it.IsEnd(); it++) {
      if ((it.GetDat() <= focusTimePoint + (e / 2)) && (it.GetDat() >= focusTimePoint - (e / 2)))
        fnodes.Add(it.GetKey());
    }

    // create graph from nodes in focus
    PNGraph g1 = TNGraph::New();
    for (int i = 0; i < fnodes.Len(); i++) {
      if (!g1->IsNode(fnodes[i]))
        g1->AddNode(fnodes[i]);
      // lower star
      for (int j = 0; j < Graph->GetNI(fnodes[i]).GetInDeg(); j++) {
        int NeighId = Graph->GetNI(fnodes[i]).GetInNId(j);
        if (t.GetDat(NeighId) < focusTimePoint - (e / 2)) {

        }
        else {
          if (!g1->IsNode(NeighId))
            g1->AddNode(NeighId);
          g1->AddEdge(NeighId, fnodes[i]);
        }
      }
      // upper star
      for (int j = 0; j < Graph->GetNI(fnodes[i]).GetOutDeg(); j++) {
        int NeighId = Graph->GetNI(fnodes[i]).GetOutNId(j);
        if (t.GetDat(NeighId) > focusTimePoint + (e / 2)) {

        }
        else {
          if (!g1->IsNode(NeighId))
            g1->AddNode(NeighId);
          g1->AddEdge(fnodes[i], NeighId);
        }
      }
    }

    // getting results from commponents detection and recording elements of components and timestamps of components
    TIntH inCompCount;
    TIntIntVH comps;
    int compBr = 0;
    TIntH nn_nodes;

    int FTP = focusTimePoint;
    TIntH TEdges;

    for (TNGraph::TNodeI NI = g1->BegNI(); NI < g1->EndNI(); NI++) {

      
      int FTPNode = NI.GetId();
      TNGraph::TNodeI GNI = Graph->GetNI(FTPNode);
      int FI, FO, RI, RO, I, O;

      RI = NI.GetInDeg();
      RO = NI.GetOutDeg();

      FI = Graph->GetNI(FTPNode).GetInDeg() - RI;
      FO = Graph->GetNI(FTPNode).GetOutDeg() - RO;

      if (focusTimePoint + (e / 2) == t.GetDat(NI.GetId())) { // if its on the right edge only in degree is observed
        RO = FO = 0;
      }
      if (focusTimePoint - (e / 2) == t.GetDat(NI.GetId())) { // if its on the left edge only out degree is observed
        RI = FI = 0;
      }

      I = RI + FI;
      O = RO + FO;

      // counting edges imidiately after time point
      int temp = 0;
      if (TEdges.IsKey(FTP))
        temp = TEdges.GetDat(FTP);
      TEdges.AddDat(FTP, O + temp);

      // FIND ELEMENTS

      // n - n,
      if (I > 1 && O > 1) {
        // number of nodes is in our out degree
        int nn = I;
        if (O > I)
          nn = O;

        TIntV nds;
        nds.Add(FTPNode);
        for (int i = 0; i < I; i++) {
          nds.Add(GNI.GetInNId(i));
        }

        for (int i = 0; i < O; i++) {
          nds.Add(GNI.GetOutNId(i));
        }

        for (int j = 0; j < nn; j++) {
          nn_nodes.AddDat(compBr);
          comps.AddDat(compBr, nds);
          compBr++;
        }
      }
      
      // 1 - n
      else if (I == 1 && O > 1) {
        for (int i = 0; i < O; i++) {
          TIntV nds;
          nds.Add(FTPNode);
          nds.Add(GNI.GetInNId(0));
          nds.Add(GNI.GetOutNId(i));
          comps.AddDat(compBr, nds);
          compBr++;
        }
      }

      // n - 1
      else if (I > 1 && O == 1) {
        for (int i = 0; i < I; i++) {
          TIntV nds;
          nds.Add(FTPNode);
          nds.Add(GNI.GetOutNId(0));
          nds.Add(GNI.GetInNId(i));
          comps.AddDat(compBr, nds);
          compBr++;
        }
      }

      // 0 - n
      else if (I == 0 && O > 1) {
        for (int i = 0; i < O; i++) {
          TIntV nds;
          nds.Add(FTPNode);
          nds.Add(GNI.GetOutNId(i));
          comps.AddDat(compBr, nds);
          compBr++;
        }
      }

      // n - 0
      else if (I > 1 && O == 0) {
        for (int i = 0; i < I; i++) {
          TIntV nds;
          nds.Add(FTPNode);
          nds.Add(GNI.GetInNId(i));
          comps.AddDat(compBr, nds);
          compBr++;
        }
      }

      // 1 - 1
      else if (I == 1 && O == 1) {
        TIntV nds;
        nds.Add(FTPNode);
        nds.Add(GNI.GetOutNId(0));
        nds.Add(GNI.GetInNId(0));
        comps.AddDat(compBr, nds);
        compBr++;
      }

      // 0 - 1
      else if (I == 0 && O == 1) {
        TIntV nds;
        nds.Add(FTPNode);
        nds.Add(GNI.GetOutNId(0));
        comps.AddDat(compBr, nds);
        compBr++;
      }

      // 1 - 0
      else if (I == 1 && O == 0) {
        TIntV nds;
        nds.Add(FTPNode);
        nds.Add(GNI.GetInNId(0));
        comps.AddDat(compBr, nds);
        compBr++;
      }

      

    } // end iterate each node

    // connecting inside of epsilon

    TIntIntVH elements;
    TIntH banned;
    for (int cc0 = 0; cc0 < comps.Len(); cc0++) {
      for (int cc1 = cc0; cc1 < comps.Len(); cc1++) {
        int smaller = comps[cc0].Len();
        int smaller_id = cc0;
        if (cc0 != cc1) {
          if (comps[cc1].Len() < smaller) {
            smaller = comps[cc1].Len();
            smaller_id = cc1;
          }
          int vi = TSnapDetail::vectorIntersect(comps[cc0], comps[cc1]);
          if (vi == smaller && !nn_nodes.IsKey(smaller_id)){
            banned.AddDat(smaller_id);
          }
          /*else if (smaller > 2 && vi == smaller - 1 && !nn_nodes.IsKey(smaller_id)) {
            TSnapDetail::transitiveTransform(comps[cc0], comps[cc1]);
            banned.AddDat(cc0);
          }*/
        }
      }
    }

    // add transitivity connection

    /*
    int max_out_tp = -1;
    int max_out = -1;
    for (THashKeyDatI<TInt, TInt> it = TEdges.BegI(); !it.IsEnd(); it++) {
      if (it.GetDat() > max_out) {
        max_out = it.GetDat();
        max_out_tp = it.GetKey();
      }
    }
    */
    for (int cc0 = 0; cc0 < comps.Len(); cc0++) {
      if (!banned.IsKey(cc0) /*&& TSnapDetail::chekIfCrossing(comps[cc0], t, first, last, max_out_tp)*/)
        elements.AddDat(cc0, comps[cc0]);
    }
    

    TIntV communitiesAtT;
    for (int cc = 0; cc < elements.Len(); cc++) {
      components.AddDat(newId, elements[cc]);
    communitiesAtT.Add(newId);
    newId++;
    }
    if (elements.Len() > 0)
      ct.AddDat(focusTimePoint, communitiesAtT);
    
  } // FOR

  // connecting neighbouring components
  THashKeyDatI<TInt, TIntV> it = ct.BegI();
  THashKeyDatI<TInt, TIntV> prelast = ct.EndI()--;
  prelast--;
  while (it < prelast) {
    TIntV cms0;
    TIntV cms1;
    int focusTimePoint;
    int focusTimePoint1;
    focusTimePoint = it.GetKey();
    cms0 = it.GetDat();
    it++;
    focusTimePoint1 = it.GetKey();
    cms1 = it.GetDat();
    if (cms0.Len() > 0 && cms1.Len() > 0) {
      for (int i = 0; i < cms0.Len(); i++) {
        for (int j = 0; j < cms1.Len(); j++) {
          TIntV ids0 = components.GetDat(cms0[i]);
          TIntV ids1 = components.GetDat(cms1[j]);
          int smaller = ids0.Len();
          if (ids1.Len() < smaller)
            smaller = ids1.Len();

          if (TSnapDetail::vectorIntersect(ids0, ids1) == smaller || (smaller > 2 && TSnapDetail::vectorIntersect(ids0, ids1) == (smaller -1 ))) {
            if (!gFinal->IsNode(cms0[i])) {
              gFinal->AddNode(cms0[i]);
              tFinal.AddDat(cms0[i], focusTimePoint);
            }
            if (!gFinal->IsNode(cms1[j])) {
              gFinal->AddNode(cms1[j]);
              tFinal.AddDat(cms1[j], focusTimePoint1);
            }
            gFinal->AddEdge(cms0[i], cms1[j]);
          }
        }
      }
    }
  }// end connecting components 

  // collapsing chains
  if (collapse) {
    for (TNGraph::TNodeI NI = gFinal->BegNI(); NI < gFinal->EndNI(); NI++) {
      if (NI.GetInDeg() == 1 && NI.GetOutDeg() == 1)
        if (gFinal->GetNI(NI.GetInNId(0)).GetOutDeg() == 1 && gFinal->GetNI(NI.GetOutNId(0)).GetInDeg() == 1)
        {
        gFinal->AddEdge(NI.GetInNId(0), NI.GetOutNId(0));
        gFinal->DelEdge(NI.GetInNId(0), NI.GetId());
        tFinal.DelKey(NI.GetId());
        gFinal->DelNode(NI.GetId());
        }
    }
  }// end collapsing

}

void TSnap::ReebSimplify	(	PNGraph &	Graph,
		TIntH &	t,
		int	e,
		PNGraph &	gFinal,
		TIntH &	tFinal,
		bool	collapse
	)

Definition at line 844 of file cmty.cpp.

                                                                                                  {
  TIntIntVH components;
  TIntIntVH ct;

  int newId = 0; //get first new free id;

  // gett first and last t
  int first = 429496729;
  int last = -1;

  // smarter way of determining focus time points
  TIntV timePoints;

  // get first and last time point
  for (THashKeyDatI<TInt, TInt> it = t.BegI(); !it.IsEnd(); it++) {
    if (it.GetDat()<first)
      first = it.GetDat();
    if (it.GetDat()>last)
      last = it.GetDat();
  }

  // adding focus timepoints
  // this can be put in the previous (first, last time point detection) iteration if breaking borders is not an issue
  for (THashKeyDatI<TInt, TInt> it = t.BegI(); !it.IsEnd(); it++) {
    if (it.GetDat() - (e / 2) >= first)
      timePoints.Add(it.GetDat() - (e / 2) /*- 0.1*/);
    timePoints.Add(it.GetDat());
    if (it.GetDat() + (e / 2) <= last)
      timePoints.Add(it.GetDat() + (e / 2) /*+ 0.1*/);
  }
  

  //iterate each time point
  for (int i = 0; i<timePoints.Len(); i++) {

    int focusTimePoint = timePoints[i];

    TIntV fnodes; // all the nodes int the focus in that step

    // getting nodes in focus -- in epsilon
    for (THashKeyDatI<TInt, TInt> it = t.BegI(); !it.IsEnd(); it++) {
      if ((it.GetDat() <= focusTimePoint + (e / 2)) && (it.GetDat() >= focusTimePoint - (e / 2)))
        fnodes.Add(it.GetKey());
    }

    // create graph from nodes in focus
    PNGraph g1 = TNGraph::New();
    for (int i = 0; i<fnodes.Len(); i++) {
      if (!g1->IsNode(fnodes[i]))
        g1->AddNode(fnodes[i]);
      // lower star
      for (int j = 0; j<Graph->GetNI(fnodes[i]).GetInDeg(); j++) {
        int NeighId = Graph->GetNI(fnodes[i]).GetInNId(j);
        if (t.GetDat(NeighId)<focusTimePoint - (e / 2)) {

        }
        else {
          if (!g1->IsNode(NeighId))
            g1->AddNode(NeighId);
          g1->AddEdge(NeighId, fnodes[i]);
        }
      }
      // upper star
      for (int j = 0; j<Graph->GetNI(fnodes[i]).GetOutDeg(); j++) {
        int NeighId = Graph->GetNI(fnodes[i]).GetOutNId(j);
        if (t.GetDat(NeighId)>focusTimePoint + (e / 2)) {

        }
        else {
          if (!g1->IsNode(NeighId))
            g1->AddNode(NeighId);
          g1->AddEdge(fnodes[i], NeighId);
        }
      }
    }

    // getting results from commponents detection and recording elements of components and timestamps of components
    TCnComV CnComV;
    GetWccs(g1, CnComV);
    TIntV communitiesAtT;
    for (int cc = 0; cc < CnComV.Len(); cc++) {
      components.AddDat(newId, CnComV[cc].NIdV);
      communitiesAtT.Add(newId);
      newId++;
    }
    if (CnComV.Len() > 0)
      ct.AddDat(focusTimePoint, communitiesAtT);
  } // end iterate each node

  // connecting neighbouring components
  THashKeyDatI<TInt, TIntV> it = ct.BegI();
  THashKeyDatI<TInt, TIntV> prelast = ct.EndI()--;
  prelast--;
  while (it < prelast) {
    TIntV cms0;
    TIntV cms1;
    int focusTimePoint;
    int focusTimePoint1;
    focusTimePoint = it.GetKey();
    cms0 = it.GetDat();
    it++;
    focusTimePoint1 = it.GetKey();
    cms1 = it.GetDat();
    if (cms0.Len()>0 && cms1.Len() > 0) {
      for (int i = 0; i < cms0.Len(); i++) {
        for (int j = 0; j < cms1.Len(); j++) {
          TIntV ids0 = components.GetDat(cms0[i]);
          TIntV ids1 = components.GetDat(cms1[j]);
          if (ids0.IntrsLen(ids1) > 0 || TSnapDetail::edgeIntersect(Graph, ids0, ids1)) {
            if (!gFinal->IsNode(cms0[i])) {
              gFinal->AddNode(cms0[i]);
              tFinal.AddDat(cms0[i], focusTimePoint);
            }
            if (!gFinal->IsNode(cms1[j])) {
              gFinal->AddNode(cms1[j]);
              tFinal.AddDat(cms1[j], focusTimePoint1);
            }
            gFinal->AddEdge(cms0[i], cms1[j]);
          }
        }
      }
    }
  }// end connecting components 

  // collapsing chains
  if (collapse) {
    for (TNGraph::TNodeI NI = gFinal->BegNI(); NI < gFinal->EndNI(); NI++) {
      if (NI.GetInDeg() == 1 && NI.GetOutDeg() == 1)
        if (gFinal->GetNI(NI.GetInNId(0)).GetOutDeg() == 1 && gFinal->GetNI(NI.GetOutNId(0)).GetInDeg() == 1)
        {
        gFinal->AddEdge(NI.GetInNId(0), NI.GetOutNId(0));
        gFinal->DelEdge(NI.GetInNId(0), NI.GetId());
        tFinal.DelKey(NI.GetId());
        gFinal->DelNode(NI.GetId());
        }
    }
  }// end collapsing

}

void TSnap::Relabel	(	TPRManager &	PRM,
		const int &	NId,
		const TNEANet::TNodeI &	NI
	)

Increases the label of a node NId to allow valid pushes to some neighbor.

Definition at line 305 of file flow.cpp.

                                                                        {
  int MaxLabel = PRM.GetMaxLabel();
  int MinLabel = MaxLabel;
  for (int EdgeN = 0; EdgeN < NI.GetInDeg(); EdgeN++) {
    if (PRM.Flow(NI.GetInEId(EdgeN)) > 0) {
      int InLabel = PRM.Label(NI.GetInNId(EdgeN));
      MinLabel = MIN(MinLabel, InLabel);
    }
  }
  for (int EdgeN = 0; EdgeN < NI.GetOutDeg(); EdgeN++) {
    if (PRM.Capacity(NI.GetOutEId(EdgeN)) > PRM.Flow(NI.GetOutEId(EdgeN))) {
      int OutLabel = PRM.Label(NI.GetOutNId(EdgeN));
      MinLabel = MIN(MinLabel, OutLabel);
    }
  }
  if (MinLabel == MaxLabel) {
    PRM.SetLabel(NId, MaxLabel);
  } else {
    PRM.SetLabel(NId, MinLabel + 1);
  }
}

template<class PGraph >

int TSnap::SamplePersonalizedPageRank	(	const PGraph &	Graph,
		double	JumpProb,
		const TIntV &	StartNIdV,
		TRnd &	Rnd
	)

Definition at line 67 of file randwalk.h.

                                                                                                        {
  int locationId = StartNIdV.GetRndVal(Rnd);
  //printf("starting walk at %d\n", locationId);
  while (Rnd.GetUniDev() >= JumpProb) {
    TNGraph::TNodeI location = Graph->GetNI(locationId);
    int d = location.GetOutDeg();
    if (d > 0)
      locationId = location.GetOutNId(Rnd.GetUniDevInt(d));
    else
      locationId = StartNIdV.GetRndVal(Rnd);
  }
  return locationId;
}

template<class PGraph >

void TSnap::SaveEdgeList	(	const PGraph &	Graph,
		const TStr &	OutFNm,
		const TStr &	Desc = TStr()
	)

Saves a graph into a text file. Each line contains two columns and encodes a single edge: <source node="" id>=""><tab><destination node="" id>="">

Definition at line 245 of file gio.h.

                                                                             {
  FILE *F = fopen(OutFNm.CStr(), "wt");
  if (HasGraphFlag(typename PGraph::TObj, gfDirected)) { fprintf(F, "# Directed graph: %s \n", OutFNm.CStr()); } 
  else { fprintf(F, "# Undirected graph (each unordered pair of nodes is saved once): %s\n", OutFNm.CStr()); }
  if (! Desc.Empty()) { fprintf(F, "# %s\n", Desc.CStr()); }
  fprintf(F, "# Nodes: %d Edges: %d\n", Graph->GetNodes(), Graph->GetEdges());
  if (HasGraphFlag(typename PGraph::TObj, gfDirected)) { fprintf(F, "# FromNodeId\tToNodeId\n"); }
  else { fprintf(F, "# NodeId\tNodeId\n"); }
  for (typename PGraph::TObj::TEdgeI ei = Graph->BegEI(); ei < Graph->EndEI(); ei++) {
    fprintf(F, "%d\t%d\n", ei.GetSrcNId(), ei.GetDstNId());
  }
  fclose(F);
}

void TSnap::SaveEdgeListNet	(	const PNEANet &	Graph,
		const TStr &	OutFNm,
		const TStr &	Desc
	)

Saves a network into a text file. Each line encodes either an edge or a node, along with its attributes.

Definition at line 269 of file gio.cpp.

                                                                                 {
  FILE *F = fopen(OutFNm.CStr(), "wt");
  fprintf(F, "# Directed network: %s \n", OutFNm.CStr());
  if (! Desc.Empty()) { fprintf(F, "# %s\n", Desc.CStr()); }
  fprintf(F, "# Nodes: %d Edges: %d\n", Graph->GetNodes(), Graph->GetEdges());

  TStrV IntAttrNNames;
  TStrV FltAttrNNames;
  TStrV StrAttrNNames;
  Graph->GetAttrNNames(IntAttrNNames, FltAttrNNames, StrAttrNNames);
  WriteNodeSchemaToFile(F, IntAttrNNames, FltAttrNNames, StrAttrNNames);
  WriteNodesToFile(F, Graph, IntAttrNNames, FltAttrNNames, StrAttrNNames);
  fprintf(F, "%s\n", END_SENTINEL.CStr());
  
  TStrV IntAttrENames;
  TStrV FltAttrENames;
  TStrV StrAttrENames;
  Graph->GetAttrENames(IntAttrENames, FltAttrENames, StrAttrENames);
  WriteEdgeSchemaToFile(F, IntAttrENames, FltAttrENames, StrAttrENames);
  WriteEdgesToFile(F, Graph, IntAttrENames, FltAttrENames, StrAttrENames);
  fprintf(F, "%s\n", END_SENTINEL.CStr());

  fclose(F);
}

template<class PGraph >

void TSnap::SaveGViz	(	const PGraph &	Graph,
		const TStr &	OutFNm,
		const TStr &	Desc = TStr(),
		const bool &	NodeLabels = false,
		const TIntStrH &	NIdColorH = TIntStrH()
	)

Save a graph in GraphVizp .DOT format.

Save a graph in GraphVizp .DOT format.

Parameters

NIdColorH

Maps node ids to node colors (see GraphViz documentation for more details).

Definition at line 387 of file gio.h.

                                                                                                                            {
  const bool IsDir = HasGraphFlag(typename PGraph::TObj, gfDirected);
  FILE *F = fopen(OutFNm.CStr(), "wt");
  if (! Desc.Empty()) fprintf(F, "/*****\n%s\n*****/\n\n", Desc.CStr());
  if (IsDir) { fprintf(F, "digraph G {\n"); } else { fprintf(F, "graph G {\n"); }
  fprintf(F, "  graph [splines=false overlap=false]\n"); //size=\"12,10\" ratio=fill
  // node  [width=0.3, height=0.3, label=\"\", style=filled, color=black]
  // node  [shape=box, width=0.3, height=0.3, label=\"\", style=filled, fillcolor=red]
  fprintf(F, "  node  [shape=ellipse, width=0.3, height=0.3%s]\n", NodeLabels?"":", label=\"\"");
  // node colors
  //for (int i = 0; i < NIdColorH.Len(); i++) {
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NIdColorH.IsKey(NI.GetId())) {
      fprintf(F, "  %d [style=filled, fillcolor=\"%s\"];\n", NI.GetId(), NIdColorH.GetDat(NI.GetId()).CStr()); }
    else {
      fprintf(F, "  %d ;\n", NI.GetId());
    }
  }
  // edges
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NI.GetOutDeg()==0 && NI.GetInDeg()==0 && !NIdColorH.IsKey(NI.GetId())) {
      fprintf(F, "%d;\n", NI.GetId()); }
    else {
      for (int e = 0; e < NI.GetOutDeg(); e++) {
        if (! IsDir && NI.GetId() > NI.GetOutNId(e)) { continue; }
        fprintf(F, "  %d %s %d;\n", NI.GetId(), IsDir?"->":"--", NI.GetOutNId(e));
      }
    }
  }
  if (! Desc.Empty()) {
    fprintf(F, "  label = \"\\n%s\\n\";", Desc.CStr());
    fprintf(F, "  fontsize=24;\n");
  }
  fprintf(F, "}\n");
  fclose(F);
}

template<class PGraph >

void TSnap::SaveGViz	(	const PGraph &	Graph,
		const TStr &	OutFNm,
		const TStr &	Desc,
		const TIntStrH &	NIdLabelH
	)

Save a graph in GraphVizp .DOT format.

Save a graph in GraphVizp .DOT format.

Parameters

NIdLabelH

Maps node ids to node string labels.

Definition at line 425 of file gio.h.

                                                                                                    {
  const bool IsDir = Graph->HasFlag(gfDirected);
  FILE *F = fopen(OutFNm.CStr(), "wt");
  if (! Desc.Empty()) fprintf(F, "/*****\n%s\n*****/\n\n", Desc.CStr());
  if (IsDir) { fprintf(F, "digraph G {\n"); } else { fprintf(F, "graph G {\n"); }
  fprintf(F, "  graph [splines=true overlap=false]\n"); //size=\"12,10\" ratio=fill
  fprintf(F, "  node  [shape=ellipse, width=0.3, height=0.3]\n");
  // node colors
  //for (int i = 0; i < NodeLabelH.Len(); i++) {
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    fprintf(F, "  %d [label=\"%s\"];\n", NI.GetId(), NIdLabelH.GetDat(NI.GetId()).CStr());
}
  // edges
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    if (NI.GetOutDeg()==0 && NI.GetInDeg()==0 && ! NIdLabelH.IsKey(NI.GetId())) {
      fprintf(F, "%d;\n", NI.GetId()); }
    else {
      for (int e = 0; e < NI.GetOutDeg(); e++) {
        if (! IsDir && NI.GetId() > NI.GetOutNId(e)) { continue; }
        fprintf(F, "  %d %s %d;\n", NI.GetId(), IsDir?"->":"--", NI.GetOutNId(e));
      }
    }
  }
  if (! Desc.Empty()) {
    fprintf(F, "  label = \"\\n%s\\n\";", Desc.CStr());
    fprintf(F, "  fontsize=24;\n");
  }
  fprintf(F, "}\n");
  fclose(F);
}

template<class PGraph >

void TSnap::SaveMatlabSparseMtx	(	const PGraph &	Graph,
		const TStr &	OutFNm
	)

Saves a graph in a MATLAB sparse matrix format.

Each line contains a tuple of 3 values: <source node="" id>=""><tab><destination node="" id>=""><tab>1.

Definition at line 369 of file gio.h.

                                                                  {
  FILE *F = fopen(OutFNm.CStr(), "wt");
  TIntSet NIdSet(Graph->GetNodes()); // so that
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    NIdSet.AddKey(NI.GetId());
  }
  for (typename PGraph::TObj::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
    const int Src = NIdSet.GetKeyId(EI.GetSrcNId())+1;
    const int Dst = NIdSet.GetKeyId(EI.GetDstNId())+1;
    fprintf(F, "%d\t%d\t1\n", Src, Dst);
    if (! HasGraphFlag(typename PGraph::TObj, gfDirected) && Src!=Dst) {
      fprintf(F, "%d\t%d\t1\n", Dst, Src);
    }
  }
  fclose(F);
}

template<class PGraph >

void TSnap::SavePajek	(	const PGraph &	Graph,
		const TStr &	OutFNm
	)

Saves a graph in a Pajek .NET format.

Definition at line 260 of file gio.h.

                                                        {
  TIntH NIdToIdH(Graph->GetNodes(), true);
  FILE *F = fopen(OutFNm.CStr(), "wt");
  fprintf(F, "*Vertices %d\n", Graph->GetNodes());
  int i = 0;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++, i++) {
    fprintf(F, "%d  \"%d\" ic Red fos 10\n", i+1, NI.GetId()); // ic: internal color, fos: font size
    NIdToIdH.AddDat(NI.GetId(), i+1);
  }
  if (HasGraphFlag(typename PGraph::TObj, gfDirected)) {
    fprintf(F, "*Arcs %d\n", Graph->GetEdges()); } // arcs are directed, edges are undirected
  else {
    fprintf(F, "*Edges %d\n", Graph->GetEdges());
  }
  for (typename PGraph::TObj::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
    const int SrcNId = NIdToIdH.GetDat(EI.GetSrcNId());
    const int DstNId = NIdToIdH.GetDat(EI.GetDstNId());
    fprintf(F, "%d %d %d c Black\n", SrcNId, DstNId, 1); // width=1
  }
  fclose(F);
}

template<class PGraph >

void TSnap::SavePajek	(	const PGraph &	Graph,
		const TStr &	OutFNm,
		const TIntStrH &	NIdColorH
	)

Saves a graph in a Pajek .NET format.

NIdColorH maps node ids to node colors. Default node color is Red. See http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/pajekman.pdf for a list of supported color names.

Definition at line 285 of file gio.h.

                                                                                   {
  TIntH NIdToIdH(Graph->GetNodes(), true);
  FILE *F = fopen(OutFNm.CStr(), "wt");
  fprintf(F, "*Vertices %d\n", Graph->GetNodes());
  int i = 0;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++, i++) {
    fprintf(F, "%d  \"%d\" ic %s fos 10\n", i+1, NI.GetId(),
      NIdColorH.IsKey(NI.GetId()) ? NIdColorH.GetDat(NI.GetId()).CStr() : "Red");
    NIdToIdH.AddDat(NI.GetId(), i+1);
  }
  if (HasGraphFlag(typename PGraph::TObj, gfDirected)) {
    fprintf(F, "*Arcs %d\n", Graph->GetEdges()); } // arcs are directed, edges are undirected
  else {
    fprintf(F, "*Edges %d\n", Graph->GetEdges());
  }
  for (typename PGraph::TObj::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
    const int SrcNId = NIdToIdH.GetDat(EI.GetSrcNId());
    const int DstNId = NIdToIdH.GetDat(EI.GetDstNId());
    fprintf(F, "%d %d %d c Black\n", SrcNId, DstNId, 1);
  }
  fclose(F);
}

template<class PGraph >

void TSnap::SavePajek	(	const PGraph &	Graph,
		const TStr &	OutFNm,
		const TIntStrH &	NIdColorH,
		const TIntStrH &	NIdLabelH
	)

Saves a graph in a Pajek .NET format.

NIdColorH maps node ids to node colors. Default node color is Red. NIdLabelH maps node ids to node string labels. See http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/pajekman.pdf for a list of supported color names.

Definition at line 312 of file gio.h.

                                                                                                              {
  TIntH NIdToIdH(Graph->GetNodes(), true);
  FILE *F = fopen(OutFNm.CStr(), "wt");
  fprintf(F, "*Vertices %d\n", Graph->GetNodes());
  int i = 0;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++, i++) {
    fprintf(F, "%d  \"%s\" ic %s fos 10\n", i+1,
      NIdLabelH.IsKey(NI.GetId()) ? NIdLabelH.GetDat(NI.GetId()).CStr() : TStr::Fmt("%d", NI.GetId()).CStr(),
      NIdColorH.IsKey(NI.GetId()) ? NIdColorH.GetDat(NI.GetId()).CStr() : "Red");
    NIdToIdH.AddDat(NI.GetId(), i+1);
  }
  if (HasGraphFlag(typename PGraph::TObj, gfDirected)) {
    fprintf(F, "*Arcs %d\n", Graph->GetEdges()); } // arcs are directed, edges are undirected
  else {
    fprintf(F, "*Edges %d\n", Graph->GetEdges());
  }
  for (typename PGraph::TObj::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
    const int SrcNId = NIdToIdH.GetDat(EI.GetSrcNId());
    const int DstNId = NIdToIdH.GetDat(EI.GetDstNId());
    fprintf(F, "%d %d %d c Black\n", SrcNId, DstNId, 1);
  }
  fclose(F);
}

template<class PGraph >

void TSnap::SavePajek	(	const PGraph &	Graph,
		const TStr &	OutFNm,
		const TIntStrH &	NIdColorH,
		const TIntStrH &	NIdLabelH,
		const TIntStrH &	EIdColorH
	)

Saves a graph in a Pajek .NET format.

NIdColorH maps node ids to node colors. Default node color is Red. NIdLabelH maps node ids to node string labels. EIdColorH maps edge ids to node colors. Default edge color is Black. See http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/pajekman.pdf for a list of supported color names.

Definition at line 341 of file gio.h.

                                                                                                                                         {
  CAssert(HasGraphFlag(typename PGraph::TObj, gfMultiGraph)); // network needs to have edge ids
  TIntH NIdToIdH(Graph->GetNodes(), true);
  FILE *F = fopen(OutFNm.CStr(), "wt");
  fprintf(F, "*Vertices %d\n", Graph->GetNodes());
  int i = 0;
  for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++, i++) {
    fprintf(F, "%d  \"%s\" ic %s fos 10\n", i+1,
      NIdLabelH.IsKey(NI.GetId()) ? NIdLabelH.GetDat(NI.GetId()).CStr() : TStr::Fmt("%d", NI.GetId()).CStr(),
      NIdColorH.IsKey(NI.GetId()) ? NIdColorH.GetDat(NI.GetId()).CStr() : "Red");
    NIdToIdH.AddDat(NI.GetId(), i+1);
  }
  if (HasGraphFlag(typename PGraph::TObj, gfDirected)) {
    fprintf(F, "*Arcs %d\n", Graph->GetEdges()); } // arcs are directed, edges are undirected
  else {
    fprintf(F, "*Edges %d\n", Graph->GetEdges());
  }
  for (typename PGraph::TObj::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
    const int SrcNId = NIdToIdH.GetDat(EI.GetSrcNId());
    const int DstNId = NIdToIdH.GetDat(EI.GetDstNId());
    fprintf(F, "%d %d 1 c %s\n", SrcNId, DstNId,
      EIdColorH.IsKey(EI.GetId()) ? EIdColorH.GetDat(EI.GetId()).CStr() : "Black");
  }
  fclose(F);
}

void TSnap::SetAllInvertSign	(	TFltV &	ValV,
		const double &	Val
	)

Definition at line 158 of file gsvd.cpp.

                                                      {
  for (int i = 0; i < ValV.Len(); i++) { 
    ValV[i] = -ValV[i]; 
  }
}

template<class PGraph >

void TSnap::TestAnf

(

)

Definition at line 240 of file anf.h.

                                       {
  PGraph Graph = PGraph::TObj::New();
  //Graph:
  //  0    2 ----> 3
  //       ^       |
  //       |       |
  //       |       ^
  //  1    5 <---- 4
  for (int v = 0; v < 6; v++) { Graph->AddNode(v); }
  Graph->AddEdge(2, 3);
  Graph->AddEdge(3, 4);
  Graph->AddEdge(4, 5);
  Graph->AddEdge(5, 2);
  TFltV AnfV;
  for (int t = 0; t < 10; t++) {
    TGraphAnf<PGraph> Anf(Graph, 128, 5, t+1);
    TIntFltKdV DistToNbrsV;
    Anf.GetGraphAnf(DistToNbrsV, 5, true);
    printf("\n--seed: %d---------------------\n", t+1);
    for (int i = 0; i < DistToNbrsV.Len(); i++) {
      printf("dist: %d\t hops:%f\n", DistToNbrsV[i].Key(), DistToNbrsV[i].Dat());
    }
    AnfV.Add(DistToNbrsV.Last().Dat);
  }
  TMom Mom(AnfV);
  printf("-----------\nAvgAnf: %f  StDev:  %f\n", Mom.GetMean(), Mom.GetSDev());//*/
  // const int NApprox = 32;
  /*printf("\nANF vs. SAMPLE diam test (10 runs of ANF, NApprox=%d):\n", NApprox);
  //Graph = TGGen<PGraph>::GenGrid(20, 20);
  Graph = TGAlg::GetMxWcc(TGGen<PGraph>::GenRnd(1000, 10000));
  TFltV FullAnf, EffAnf;
  for (int tryn = 0; tryn < 10; tryn++) {
    FullAnf.Add(GetEffDiam(Graph, false, 1.0, NApprox));
    EffAnf.Add(GetEffDiam(Graph, false, 0.9, NApprox));
  }
  TMom FullMom(FullAnf);
  TMom AnfMom(EffAnf);
  printf("  Sample FullDiam:      %d\n", TGAlg::GetBfsFullDiam(Graph, 100, false));
  printf("  Anf    FullDiam:      %f  [%f]\n", FullMom.GetMean(), FullMom.GetSDev());
  printf("  Sample EffDiam [90%%]: %f\n", TGAlg::GetBfsEffDiam(Graph, 100, false));
  printf("  Anf    EffDiam [90%%]: %f  [%f]\n", AnfMom.GetMean(), AnfMom.GetSDev());
  // epinions
  printf("\nEpinions graph:\n");
  { typedef PNGraph PGraph;
  PGraph G = TGGen<PGraph>::GenEpinions();
  TIntFltKdV DistToPairsV;
  GetAnf(G, DistToPairsV, 50, true);
  for(int i = 0; i < DistToPairsV.Len(); i++) {
    printf("\t%d\t%f\n", DistToPairsV[i].Key, DistToPairsV[i].Dat); }
  printf("\nUndir\n");
  TAnf<PGraph>::GetAnf(G, DistToPairsV, 50, false);
  for(int j = 0; j < DistToPairsV.Len(); j++) {
    printf("\t%d\t%f\n", DistToPairsV[j].Key, DistToPairsV[j].Dat); }
  }//*/
}

void TSnap::TFltVToNumpy	(	TFltV &	FltV,
		float *	FltNumpyVecOut,
		int	n
	)

Converts TFltV to Numpy array.

Fills the numpyvec array with TFltV vector values. Note that only the first n values are filled.

Definition at line 15 of file numpy.cpp.

                                                             {
                int limit = MIN(FltV.Len(), n);

    for (int i=0; i < limit; i++) {
        FltNumpyVecOut[i] = static_cast<float>(FltV[i]);
                }
}

void TSnap::TIntVToNumpy	(	TIntV &	IntV,
		int *	IntNumpyVecOut,
		int	n
	)

Converts TIntV to Numpy array.

Fills the numpyvec array with TIntV vector values. Note that only the first n values are filled.

Definition at line 4 of file numpy.cpp.

                                                           {
                int limit = MIN(IntV.Len(), n);

    for (int i=0; i < limit; i++) {
        IntNumpyVecOut[i] = IntV[i];
                }
}

template<class PGraph >

PGraph TSnap::ToGraph	(	PTable	Table,
		const TStr &	SrcCol,
		const TStr &	DstCol,
		TAttrAggr	AggrPolicy
	)

Sequentially converts the table into a graph with links from nodes in SrcCol to those in DstCol.

Converts table to a directed/undirected graph. Suitable for PUNGraph and PNGraph, but not for PNEANet where attributes are expected.

Definition at line 8 of file conv.h.

{
        PGraph Graph = PGraph::TObj::New();

  const TAttrType NodeType = Table->GetColType(SrcCol);
  Assert(NodeType == Table->GetColType(DstCol));
  const TInt SrcColIdx = Table->GetColIdx(SrcCol);
  const TInt DstColIdx = Table->GetColIdx(DstCol);

  // make single pass over all rows in the table
  if (NodeType == atInt) {
    for (int CurrRowIdx = 0; CurrRowIdx < (Table->Next).Len(); CurrRowIdx++) {
      if ((Table->Next)[CurrRowIdx] == Table->Invalid) { continue; }
      // add src and dst nodes to graph if they are not seen earlier
      TInt SVal = (Table->IntCols)[SrcColIdx][CurrRowIdx];
      TInt DVal = (Table->IntCols)[DstColIdx][CurrRowIdx];
      //Using AddNodeUnchecked ensures that no error is thrown when the same node is seen twice
      Graph->AddNodeUnchecked(SVal);
      Graph->AddNodeUnchecked(DVal);
      Graph->AddEdgeUnchecked(SVal, DVal);
    }
  } else if (NodeType == atFlt) {
    // node values - i.e. the unique values of src/dst col
    //THashSet<TInt> IntNodeVals; // for both int and string node attr types.
    THash<TFlt, TInt> FltNodeVals;
    for (int CurrRowIdx = 0; CurrRowIdx < (Table->Next).Len(); CurrRowIdx++) {
      if ((Table->Next)[CurrRowIdx] == Table->Invalid) { continue; }
      // add src and dst nodes to graph if they are not seen earlier
      TInt SVal, DVal;
      TFlt FSVal = (Table->FltCols)[SrcColIdx][CurrRowIdx];
      SVal = Table->CheckAndAddFltNode(Graph, FltNodeVals, FSVal);
      TFlt FDVal = (Table->FltCols)[SrcColIdx][CurrRowIdx];
      DVal = Table->CheckAndAddFltNode(Graph, FltNodeVals, FDVal);
      Graph->AddEdge(SVal, DVal);
    }
  } else {
    for (int CurrRowIdx = 0; CurrRowIdx < (Table->Next).Len(); CurrRowIdx++) {
      if ((Table->Next)[CurrRowIdx] == Table->Invalid) { continue; }
      // add src and dst nodes to graph if they are not seen earlier
      TInt SVal = (Table->StrColMaps)[SrcColIdx][CurrRowIdx];
//      if (strlen(Table->GetContextKey(SVal)) == 0) { continue; }  //illegal value
      TInt DVal = (Table->StrColMaps)[DstColIdx][CurrRowIdx];
//      if (strlen(Table->GetContextKey(DVal)) == 0) { continue; }  //illegal value
      //Using AddNodeUnchecked ensures that no error is thrown when the same node is seen twice
      Graph->AddNodeUnchecked(SVal);
      Graph->AddNodeUnchecked(DVal);
      Graph->AddEdgeUnchecked(SVal, DVal);
    }
  }

  Graph->SortNodeAdjV();
  return Graph;
}

template<class PGraphMP >

PGraphMP TSnap::ToGraphMP	(	PTable	Table,
		const TStr &	SrcCol,
		const TStr &	DstCol
	)

Performs table to graph conversion in parallel using the sort-first algorithm. This is the recommended method to use.

Definition at line 192 of file conv.h.

                                                                         {
  // double start = omp_get_wtime();
  const TInt SrcColIdx = Table->GetColIdx(SrcCol);
  const TInt DstColIdx = Table->GetColIdx(DstCol);
  const TAttrType NodeType = Table->GetColType(SrcCol);
  Assert(NodeType == Table->GetColType(DstCol));

  const TInt NumRows = Table->NumValidRows;

  TIntV SrcCol1, DstCol1, SrcCol2, DstCol2;

  #pragma omp parallel sections num_threads(4)
  {
    #pragma omp section
    { SrcCol1.Reserve(NumRows, NumRows); }
    #pragma omp section
    { SrcCol2.Reserve(NumRows, NumRows); }
    #pragma omp section
    { DstCol1.Reserve(NumRows, NumRows); }
    #pragma omp section
    { DstCol2.Reserve(NumRows, NumRows); }
  }

  // double endResize = omp_get_wtime();
  // printf("Resize time = %f\n", endResize-start);

  TIntPrV Partitions;
  Table->GetPartitionRanges(Partitions, omp_get_max_threads());
  TInt PartitionSize = Partitions[0].GetVal2()-Partitions[0].GetVal1()+1;

  // double endPartition = omp_get_wtime();
  // printf("Partition time = %f\n", endPartition-endResize);

  omp_set_num_threads(omp_get_max_threads());
  if (NodeType == atInt) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx();
        SrcCol1[RowId] = RowI.GetIntAttr(SrcColIdx);
        SrcCol2[RowId] = RowI.GetIntAttr(SrcColIdx);
        DstCol1[RowId] = RowI.GetIntAttr(DstColIdx);
        DstCol2[RowId] = RowI.GetIntAttr(DstColIdx);
        RowI++;
      }
    }
  }
  else if (NodeType == atStr) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx();
        SrcCol1[RowId] = RowI.GetStrMapById(SrcColIdx);
        SrcCol2[RowId] = RowI.GetStrMapById(SrcColIdx);
        DstCol1[RowId] = RowI.GetStrMapById(DstColIdx);
        DstCol2[RowId] = RowI.GetStrMapById(DstColIdx);
        RowI++;
      }
    }
  }

  omp_set_num_threads(omp_get_max_threads());
  #pragma omp parallel
  {
    #pragma omp single nowait
    {
      #pragma omp task untied shared(SrcCol1, DstCol1)
      { TTable::QSortKeyVal(SrcCol1, DstCol1, 0, NumRows-1); }
    }
    #pragma omp single nowait
    {
      #pragma omp task untied shared(SrcCol2, DstCol2)
     { TTable::QSortKeyVal(DstCol2, SrcCol2, 0, NumRows-1); }
    }
    #pragma omp taskwait
  }

  // TTable::PSRSKeyVal(SrcCol1, DstCol1, 0, NumRows-1);
  // TTable::PSRSKeyVal(DstCol2, SrcCol2, 0, NumRows-1);

  // TInt IsS = TTable::CheckSortedKeyVal(SrcCol1, DstCol1, 0, NumRows-1);
  // TInt IsD = TTable::CheckSortedKeyVal(DstCol2, SrcCol2, 0, NumRows-1);
  // printf("IsSorted = %d %d\n", IsS.Val, IsD.Val);

  // double endSort = omp_get_wtime();
  // printf("Sort time = %f\n", endSort-endCopy);
  //return TNGraphMP::New(10, 100);

  TInt NumThreads = omp_get_max_threads();
  TInt PartSize = (NumRows/NumThreads);

  TIntV SrcOffsets, DstOffsets;
  SrcOffsets.Add(0);
  for (TInt i = 1; i < NumThreads; i++) {
    TInt CurrOffset = i * PartSize;
    while (CurrOffset < (i+1) * PartSize &&
          SrcCol1[CurrOffset-1] == SrcCol1[CurrOffset]) {
      CurrOffset++;
    }
    if (CurrOffset < (i+1) * PartSize) { SrcOffsets.Add(CurrOffset); }
  }
  SrcOffsets.Add(NumRows);

  DstOffsets.Add(0);
  for (TInt i = 1; i < NumThreads; i++) {
    TInt CurrOffset = i * PartSize;
    while (CurrOffset < (i+1) * PartSize &&
          DstCol2[CurrOffset-1] == DstCol2[CurrOffset]) {
      CurrOffset++;
    }
    if (CurrOffset < (i+1) * PartSize) { DstOffsets.Add(CurrOffset); }
  }
  DstOffsets.Add(NumRows);

  TInt SrcPartCnt = SrcOffsets.Len()-1;
  TInt DstPartCnt = DstOffsets.Len()-1;

  // for (TInt i = 0; i < SrcOffsets.Len(); i++) {
  //   printf("%d ", SrcOffsets[i].Val);
  // }
  // printf("\n");
  // for (TInt i = 0; i < DstOffsets.Len(); i++) {
  //   printf("%d ", DstOffsets[i].Val);
  // }
  // printf("\n");

  TIntV SrcNodeCounts, DstNodeCounts;
  SrcNodeCounts.Reserve(SrcPartCnt, SrcPartCnt);
  DstNodeCounts.Reserve(DstPartCnt, DstPartCnt);

  #pragma omp parallel for schedule(dynamic)
  for (int t = 0; t < SrcPartCnt+DstPartCnt; t++) {
    if (t < SrcPartCnt) {
      TInt i = t;
      if (SrcOffsets[i] != SrcOffsets[i+1]) {
        SrcNodeCounts[i] = 1;
        TInt CurrNode = SrcCol1[SrcOffsets[i]];
        for (TInt j = SrcOffsets[i]+1; j < SrcOffsets[i+1]; j++) {
          while (j < SrcOffsets[i+1] && SrcCol1[j] == CurrNode) { j++; }
          if (j < SrcOffsets[i+1]) {
            SrcNodeCounts[i]++;
            CurrNode = SrcCol1[j];
          }
        }
      }
    } else {
      TInt i = t - SrcPartCnt;
      if (DstOffsets[i] != DstOffsets[i+1]) {
        DstNodeCounts[i] = 1;
        TInt CurrNode = DstCol2[DstOffsets[i]];
        for (TInt j = DstOffsets[i]+1; j < DstOffsets[i+1]; j++) {
          while (j < DstOffsets[i+1] && DstCol2[j] == CurrNode) { j++; }
          if (j < DstOffsets[i+1]) {
            DstNodeCounts[i]++;
            CurrNode = DstCol2[j];
          }
        }
      }
    }
  }

  // for (TInt i = 0; i < SrcNodeCounts.Len(); i++) {
  //   printf("%d ", SrcNodeCounts[i].Val);
  // }
  // printf("\n");
  // for (TInt i = 0; i < DstNodeCounts.Len(); i++) {
  //   printf("%d ", DstNodeCounts[i].Val);
  // }
  // printf("\n");

  TInt TotalSrcNodes = 0;
  TIntV SrcIdOffsets;
  for (int i = 0; i < SrcPartCnt; i++) {
    SrcIdOffsets.Add(TotalSrcNodes);
    TotalSrcNodes += SrcNodeCounts[i];
  }

  TInt TotalDstNodes = 0;
  TIntV DstIdOffsets;
  for (int i = 0; i < DstPartCnt; i++) {
    DstIdOffsets.Add(TotalDstNodes);
    TotalDstNodes += DstNodeCounts[i];
  }

  // printf("Total Src = %d, Total Dst = %d\n", TotalSrcNodes.Val, TotalDstNodes.Val);

  TIntPrV SrcNodeIds, DstNodeIds;
  #pragma omp parallel sections
  {
    #pragma omp section
    { SrcNodeIds.Reserve(TotalSrcNodes, TotalSrcNodes); }
    #pragma omp section
    { DstNodeIds.Reserve(TotalDstNodes, TotalDstNodes); }
  }

  #pragma omp parallel for schedule(dynamic)
  for (int t = 0; t < SrcPartCnt+DstPartCnt; t++) {
    if (t < SrcPartCnt) {
      TInt i = t;
      if (SrcOffsets[i] != SrcOffsets[i+1]) {
        TInt CurrNode = SrcCol1[SrcOffsets[i]];
        TInt ThreadOffset = SrcIdOffsets[i];
        SrcNodeIds[ThreadOffset] = TIntPr(CurrNode, SrcOffsets[i]);
        TInt CurrCount = 1;
        for (TInt j = SrcOffsets[i]+1; j < SrcOffsets[i+1]; j++) {
          while (j < SrcOffsets[i+1] && SrcCol1[j] == CurrNode) { j++; }
          if (j < SrcOffsets[i+1]) {
            CurrNode = SrcCol1[j];
            SrcNodeIds[ThreadOffset+CurrCount] = TIntPr(CurrNode, j);
            CurrCount++;
          }
        }
      }
    } else {
      TInt i = t - SrcPartCnt;
      if (DstOffsets[i] != DstOffsets[i+1]) {
        TInt CurrNode = DstCol2[DstOffsets[i]];
        TInt ThreadOffset = DstIdOffsets[i];
        DstNodeIds[ThreadOffset] = TIntPr(CurrNode, DstOffsets[i]);
        TInt CurrCount = 1;
        for (TInt j = DstOffsets[i]+1; j < DstOffsets[i+1]; j++) {
          while (j < DstOffsets[i+1] && DstCol2[j] == CurrNode) { j++; }
          if (j < DstOffsets[i+1]) {
            CurrNode = DstCol2[j];
            DstNodeIds[ThreadOffset+CurrCount] = TIntPr(CurrNode, j);
            CurrCount++;
          }
        }
      }
    }
  }

  // double endNode = omp_get_wtime();
  // printf("Node time = %f\n", endNode-endSort);

  TIntTrV Nodes;
  Nodes.Reserve(TotalSrcNodes+TotalDstNodes);

  // double endNodeResize = omp_get_wtime();
  // printf("(NodeResize time = %f)\n", endNodeResize-endNode);

  TInt i = 0, j = 0;
  while (i < TotalSrcNodes && j < TotalDstNodes) {
    if (SrcNodeIds[i].Val1 == DstNodeIds[j].Val1) {
      Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, j));
      i++;
      j++;
    } else if (SrcNodeIds[i].Val1 < DstNodeIds[j].Val1) {
      Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, -1));
      i++;
    } else {
      Nodes.Add(TIntTr(DstNodeIds[j].Val1, -1, j));
      j++;
    }
  }
  for (; i < TotalSrcNodes; i++) { Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, -1)); }
  for (; j < TotalDstNodes; j++) { Nodes.Add(TIntTr(DstNodeIds[j].Val1, -1, j)); }

  // double endMerge = omp_get_wtime();
  // printf("Merge time = %f\n", endMerge-endNode);

  TInt NumNodes = Nodes.Len();
  // printf("NumNodes = %d\n", NumNodes.Val);

  PGraphMP Graph = TNGraphMP::New(NumNodes, NumRows);
  NumThreads = 1;
  int Delta = (NumNodes+NumThreads-1)/NumThreads;

  TVec<TIntV> InVV(NumNodes);
  TVec<TIntV> OutVV(NumNodes);

  omp_set_num_threads(NumThreads);
  #pragma omp parallel for schedule(static,Delta)
  for (int m = 0; m < NumNodes; m++) {
    //double startTr = omp_get_wtime();
    //TIntV OutV, InV;
    TInt n, i, j;
    Nodes[m].GetVal(n, i, j);
    if (i >= 0) {
      TInt Offset = SrcNodeIds[i].GetVal2();
      TInt Sz = DstCol1.Len()-Offset;
      if (i < SrcNodeIds.Len()-1) { Sz = SrcNodeIds[i+1].GetVal2()-Offset; }
      //printf("OutV: %d %d %d\n", n.Val, Offset.Val, Sz.Val);
      OutVV[m].Reserve(Sz);
    }
    if (j >= 0) {
      TInt Offset = DstNodeIds[j].GetVal2();
      TInt Sz = SrcCol2.Len()-Offset;
      if (j < DstNodeIds.Len()-1) { Sz = DstNodeIds[j+1].GetVal2()-Offset; }
      //printf("OutV: %d %d %d\n", n.Val, Offset.Val, Sz.Val);
      InVV[m].Reserve(Sz);
    }
    //double endTr = omp_get_wtime();
    //printf("Thread=%d, i=%d, t=%f\n", omp_get_thread_num(), m, endTr-startTr);
  }

  // double endAlloc = omp_get_wtime();
  // printf("Alloc time = %f\n", endAlloc-endMerge);

  NumThreads = omp_get_max_threads();
  Delta = (NumNodes+NumThreads-1)/(10*NumThreads);
  omp_set_num_threads(NumThreads);
  #pragma omp parallel for schedule(dynamic)
  for (int m = 0; m < NumNodes; m++) {
    //double startTr = omp_get_wtime();
    //TIntV OutV, InV;
    TInt n, i, j;
    Nodes[m].GetVal(n, i, j);
    if (i >= 0) {
      TInt Offset = SrcNodeIds[i].GetVal2();
      TInt Sz = DstCol1.Len()-Offset;
      if (i < SrcNodeIds.Len()-1) { Sz = SrcNodeIds[i+1].GetVal2()-Offset; }
      //printf("OutV: %d %d %d\n", n.Val, Offset.Val, Sz.Val);
      OutVV[m].CopyUniqueFrom(DstCol1, Offset, Sz);
    }
    if (j >= 0) {
      TInt Offset = DstNodeIds[j].GetVal2();
      TInt Sz = SrcCol2.Len()-Offset;
      if (j < DstNodeIds.Len()-1) { Sz = DstNodeIds[j+1].GetVal2()-Offset; }
      //printf("OutV: %d %d %d\n", n.Val, Offset.Val, Sz.Val);
      InVV[m].CopyUniqueFrom(SrcCol2, Offset, Sz);
    }
    Graph->AddNodeWithEdges(n, InVV[m], OutVV[m]);
    //double endTr = omp_get_wtime();
    //printf("Thread=%d, i=%d, t=%f\n", omp_get_thread_num(), m, endTr-startTr);
  }
  Graph->SetNodes(NumNodes);

  // double endAdd = omp_get_wtime();
  // printf("Add time = %f\n", endAdd-endAlloc);

  return Graph;
}

template<class PGraphMP >

PGraphMP TSnap::ToGraphMP3	(	PTable	Table,
		const TStr &	SrcCol,
		const TStr &	DstCol
	)

Performs table to graph conversion in parallel. Uses the hash-first method, which is less optimal, use ToGraphMP instead.

Definition at line 532 of file conv.h.

                                                                          {
  PNGraphMP Graph;
  int MaxThreads = omp_get_max_threads();
  int Length, Threads, Delta, Nodes, Last;
  uint64_t NumNodesEst;
  TInt SrcColIdx, DstColIdx;
  TIntV InVec, OutVec;

  SrcColIdx = Table->GetColIdx(SrcCol);
  DstColIdx = Table->GetColIdx(DstCol);
  const TAttrType NodeType = Table->GetColType(SrcCol);
  Assert(NodeType == Table->GetColType(DstCol));


  /* Estimate number of nodes in the graph */
  int NumRows = Table->Next.Len();
  double Load = 10;
  int sz = NumRows / Load;
  int *buckets = (int *)malloc(sz * sizeof(int));

  #pragma omp parallel for
    for (int i = 0; i < sz; i++)
      buckets[i] = 0;

  if (NodeType == atInt) {
    #pragma omp parallel for
      for (int i = 0; i < NumRows; i++) {
        int vert = Table->IntCols[DstColIdx][i];
        buckets[vert % sz] = 1;
      }
  }
  else if (NodeType == atStr ) {
    #pragma omp parallel for
      for (int i = 0; i < NumRows; i++) {
        int vert = (Table->StrColMaps)[DstColIdx][i];
        buckets[vert % sz] = 1;
      }
  }
  int cnt = 0;
  #pragma omp parallel for reduction(+:cnt)
    for (int i = 0; i < sz; i++) {
      if (buckets[i] == 0)
        cnt += 1;
  }

  NumNodesEst = sz * log ((double)sz / cnt);
  free (buckets);

  /* Until we correctly estimate the number of nodes */
  while (1)
  {
    Graph = TNGraphMP::New(NumNodesEst, 100);

    Length = Graph->Reserved();
    Threads = MaxThreads/2;
    Delta = (Length + Threads - 1) / Threads;

    OutVec.Gen(Length);
    InVec.Gen(Length);

    /* build the node hash table, count the size of edge lists */
    Last = NumRows;
    Nodes = 0;
    omp_set_num_threads(Threads);
    #pragma omp parallel for schedule(static, Delta)
      for (int CurrRowIdx = 0; CurrRowIdx < Last; CurrRowIdx++) {
        if ((uint64_t) Nodes + 1000 >= NumNodesEst) {
          /* need bigger hash table */
          continue;
        }

        TInt SVal, DVal;
        if (NodeType == atInt) {
          SVal = Table->IntCols[SrcColIdx][CurrRowIdx];
          DVal = Table->IntCols[DstColIdx][CurrRowIdx];
        }
        else if (NodeType == atStr ) {
          SVal = (Table->StrColMaps)[SrcColIdx][CurrRowIdx];
          DVal = (Table->StrColMaps)[DstColIdx][CurrRowIdx];
        }
        int SrcIdx = abs((SVal.GetPrimHashCd()) % Length);
        if (!Graph->AddOutEdge1(SrcIdx, SVal, DVal)) {
          #pragma omp critical
          {
                  Nodes++;
          }
        }
        __sync_fetch_and_add(&OutVec[SrcIdx].Val, 1);

        int DstIdx = abs((DVal.GetPrimHashCd()) % Length);
        if (!Graph->AddInEdge1(DstIdx, SVal, DVal)) {
          #pragma omp critical
          {
            Nodes++;
          }
        }
        __sync_fetch_and_add(&InVec[DstIdx].Val, 1);

      }
    if ((uint64_t) Nodes + 1000 >= NumNodesEst) {
      /* We need to double our num nodes estimate */
      Graph.Clr();
      InVec.Clr();
      OutVec.Clr();
      NumNodesEst *= 2;
    }
    else {
      break;
    }
  }

  Graph->SetNodes(Nodes);

  uint Edges = 0;
  for (int i = 0; i < Length; i++) {
    Edges += OutVec[i] + InVec[i];
  }

  for (int Idx = 0; Idx < Length; Idx++) {
    if (OutVec[Idx] > 0 || InVec[Idx] > 0) {
      Graph->ReserveNodeDegs(Idx, InVec[Idx], OutVec[Idx]);
    }
  }

  /* assign edges */
  Length = Graph->Reserved();
  Threads = MaxThreads;
  Delta = (Length + Threads - 1) / Threads;

  omp_set_num_threads(Threads);
  #pragma omp parallel for schedule(static,Delta)
  for (int CurrRowIdx = 0; CurrRowIdx < Last; CurrRowIdx++) {
        TInt SVal, DVal;
        if (NodeType == atInt) {
      SVal = Table->IntCols[SrcColIdx][CurrRowIdx];
      DVal = Table->IntCols[DstColIdx][CurrRowIdx];
        }
        else if (NodeType == atStr) {
      SVal = (Table->StrColMaps)[SrcColIdx][CurrRowIdx];
      DVal = (Table->StrColMaps)[DstColIdx][CurrRowIdx];
        }

    Graph->AddOutEdge2(SVal, DVal);
    Graph->AddInEdge2(SVal, DVal);
  }

  /* sort edges */
  Length = Graph->Reserved();
  Threads = MaxThreads*2;
  Delta = (Length + Threads - 1) / Threads;

  omp_set_num_threads(Threads);
  #pragma omp parallel for schedule(dynamic)
  for (int Idx = 0; Idx < Length; Idx++) {
    if (OutVec[Idx] > 0 || InVec[Idx] > 0) {
      Graph->SortEdges(Idx, InVec[Idx], OutVec[Idx]);
    }
  }

  return Graph;
}

template<class PGraph >

PGraph TSnap::ToNetwork	(	PTable	Table,
		const TStr &	SrcCol,
		const TStr &	DstCol,
		TStrV &	SrcAttrV,
		TStrV &	DstAttrV,
		TStrV &	EdgeAttrV,
		TAttrAggr	AggrPolicy
	)

Converts the Table into a graph with edges from SrcCol to DstCol, and attribute vector defined by the arguments.

Converts table to a network. Suitable for PNEANet - Requires node and edge attribute column names as vectors.

Definition at line 64 of file conv.h.

{
        PGraph Graph = PGraph::TObj::New();

  const TAttrType NodeType = Table->GetColType(SrcCol);
  Assert(NodeType == Table->GetColType(DstCol));
  const TInt SrcColIdx = Table->GetColIdx(SrcCol);
  const TInt DstColIdx = Table->GetColIdx(DstCol);

        //Table->AddGraphAttributeV(SrcAttrV, false, true, false);
        //Table->AddGraphAttributeV(DstAttrV, false, false, true);
        //Table->AddGraphAttributeV(EdgeAttrV, true, false, true);

  // node values - i.e. the unique values of src/dst col
  //THashSet<TInt> IntNodeVals; // for both int and string node attr types.
  THash<TFlt, TInt> FltNodeVals;

  // node attributes
  THash<TInt, TStrIntVH> NodeIntAttrs;
  THash<TInt, TStrFltVH> NodeFltAttrs;
  THash<TInt, TStrStrVH> NodeStrAttrs;

  // make single pass over all rows in the table
  for (int CurrRowIdx = 0; CurrRowIdx < (Table->Next).Len(); CurrRowIdx++) {
    if ((Table->Next)[CurrRowIdx] == Table->Invalid) {
      continue;
    }

    // add src and dst nodes to graph if they are not seen earlier
   TInt SVal, DVal;
    if (NodeType == atFlt) {
      TFlt FSVal = (Table->FltCols)[SrcColIdx][CurrRowIdx];
      SVal = Table->CheckAndAddFltNode(Graph, FltNodeVals, FSVal);
      TFlt FDVal = (Table->FltCols)[SrcColIdx][CurrRowIdx];
      DVal = Table->CheckAndAddFltNode(Graph, FltNodeVals, FDVal);
    } else if (NodeType == atInt || NodeType == atStr) {
      if (NodeType == atInt) {
        SVal = (Table->IntCols)[SrcColIdx][CurrRowIdx];
        DVal = (Table->IntCols)[DstColIdx][CurrRowIdx];
      } else {
        SVal = (Table->StrColMaps)[SrcColIdx][CurrRowIdx];
        if (strlen(Table->GetContextKey(SVal)) == 0) { continue; }  //illegal value
        DVal = (Table->StrColMaps)[DstColIdx][CurrRowIdx];
        if (strlen(Table->GetContextKey(DVal)) == 0) { continue; }  //illegal value
      }
      if (!Graph->IsNode(SVal)) {Graph->AddNode(SVal); }
      if (!Graph->IsNode(DVal)) {Graph->AddNode(DVal); }
      //CheckAndAddIntNode(Graph, IntNodeVals, SVal);
      //CheckAndAddIntNode(Graph, IntNodeVals, DVal);
    }

    // add edge and edge attributes
    Graph->AddEdge(SVal, DVal, CurrRowIdx);

                // Aggregate edge attributes and add to graph
                for (TInt i = 0; i < EdgeAttrV.Len(); i++) {
                        TStr ColName = EdgeAttrV[i];
                        TAttrType T = Table->GetColType(ColName);
                        TInt Index = Table->GetColIdx(ColName);
                        switch (T) {
                                case atInt:
                                        Graph->AddIntAttrDatE(CurrRowIdx, Table->IntCols[Index][CurrRowIdx], ColName);
                                        break;
                                case atFlt:
                                        Graph->AddFltAttrDatE(CurrRowIdx, Table->FltCols[Index][CurrRowIdx], ColName);
                                        break;
                                case atStr:
                                        Graph->AddStrAttrDatE(CurrRowIdx, Table->GetStrValIdx(Index, CurrRowIdx), ColName);
                                        break;
                        }
                }

    // get src and dst node attributes into hashmaps
    if ((Table->SrcNodeAttrV).Len() > 0) {
      Table->AddNodeAttributes(SVal, Table->SrcNodeAttrV, CurrRowIdx, NodeIntAttrs, NodeFltAttrs, NodeStrAttrs);
        }

    if ((Table->DstNodeAttrV).Len() > 0) {
      Table->AddNodeAttributes(DVal, Table->DstNodeAttrV, CurrRowIdx, NodeIntAttrs, NodeFltAttrs, NodeStrAttrs);
    }
  }

  // aggregate node attributes and add to graph
  if ((Table->SrcNodeAttrV).Len() > 0 || (Table->DstNodeAttrV).Len() > 0) {
    for (TNEANet::TNodeI NodeI = Graph->BegNI(); NodeI < Graph->EndNI(); NodeI++) {
      TInt NId = NodeI.GetId();
      if (NodeIntAttrs.IsKey(NId)) {
        TStrIntVH IntAttrVals = NodeIntAttrs.GetDat(NId);
        for (TStrIntVH::TIter it = IntAttrVals.BegI(); it < IntAttrVals.EndI(); it++) {
          TInt AttrVal = Table->AggregateVector<TInt>(it.GetDat(), AggrPolicy);
          Graph->AddIntAttrDatN(NId, AttrVal, it.GetKey());
        }
      }
      if (NodeFltAttrs.IsKey(NId)) {
        TStrFltVH FltAttrVals = NodeFltAttrs.GetDat(NId);
        for (TStrFltVH::TIter it = FltAttrVals.BegI(); it < FltAttrVals.EndI(); it++) {
          TFlt AttrVal = Table->AggregateVector<TFlt>(it.GetDat(), AggrPolicy);
          Graph->AddFltAttrDatN(NId, AttrVal, it.GetKey());
        }
      }
      if (NodeStrAttrs.IsKey(NId)) {
        TStrStrVH StrAttrVals = NodeStrAttrs.GetDat(NId);
        for (TStrStrVH::TIter it = StrAttrVals.BegI(); it < StrAttrVals.EndI(); it++) {
          TStr AttrVal = Table->AggregateVector<TStr>(it.GetDat(), AggrPolicy);
          Graph->AddStrAttrDatN(NId, AttrVal, it.GetKey());
        }
      }
    }
  }

  return Graph;
}

template<class PGraph >

PGraph TSnap::ToNetwork	(	PTable	Table,
		const TStr &	SrcCol,
		const TStr &	DstCol,
		TAttrAggr	AggrPolicy
	)

Calls ToNetwork with an empty attribute vector. Convenience wrapper.

Converts table to a network. Suitable for PNEANet - Assumes no node and edge attributes.

Definition at line 182 of file conv.h.

{
  TStrV V;
  return ToNetwork<PGraph>(Table, SrcCol, DstCol, V, AggrPolicy);
}

template<class PGraph >

PGraph TSnap::ToNetwork	(	PTable	Table,
		const TStr &	SrcCol,
		const TStr &	DstCol,
		TStrV &	EdgeAttrV,
		TAttrAggr	AggrPolicy
	)

Converts table to a network sequentially. Use if network has only edge attributes.

Definition at line 1572 of file conv.h.

                        {
  PGraph Graph = PGraph::TObj::New();

  const TAttrType NodeType = Table->GetColType(SrcCol);
  Assert(NodeType == Table->GetColType(DstCol));
  const TInt SrcColIdx = Table->GetColIdx(SrcCol);
  const TInt DstColIdx = Table->GetColIdx(DstCol);

        //Table->AddGraphAttributeV(SrcAttrV, false, true, false);
        //Table->AddGraphAttributeV(DstAttrV, false, false, true);
        //Table->AddGraphAttributeV(EdgeAttrV, true, false, true);

  // node values - i.e. the unique values of src/dst col
  //THashSet<TInt> IntNodeVals; // for both int and string node attr types.
  THash<TFlt, TInt> FltNodeVals;

  // make single pass over all rows in the table
  for (int CurrRowIdx = 0; CurrRowIdx < (Table->Next).Len(); CurrRowIdx++) {
    if ((Table->Next)[CurrRowIdx] == Table->Invalid) {
      continue;
    }

    // add src and dst nodes to graph if they are not seen earlier
    TInt SVal, DVal;
    if (NodeType == atFlt) {
      TFlt FSVal = (Table->FltCols)[SrcColIdx][CurrRowIdx];
      SVal = Table->CheckAndAddFltNode(Graph, FltNodeVals, FSVal);
      TFlt FDVal = (Table->FltCols)[SrcColIdx][CurrRowIdx];
      DVal = Table->CheckAndAddFltNode(Graph, FltNodeVals, FDVal);
    }
    else if (NodeType == atInt || NodeType == atStr) {
      if (NodeType == atInt) {
        SVal = (Table->IntCols)[SrcColIdx][CurrRowIdx];
        DVal = (Table->IntCols)[DstColIdx][CurrRowIdx];
      }
      else {
        SVal = (Table->StrColMaps)[SrcColIdx][CurrRowIdx];
  //        if (strlen(Table->GetContextKey(SVal)) == 0) { continue; }  //illegal value
        DVal = (Table->StrColMaps)[DstColIdx][CurrRowIdx];
  //        if (strlen(Table->GetContextKey(DVal)) == 0) { continue; }  //illegal value
      }
      if (!Graph->IsNode(SVal)) {Graph->AddNode(SVal); }
      if (!Graph->IsNode(DVal)) {Graph->AddNode(DVal); }
        //CheckAndAddIntNode(Graph, IntNodeVals, SVal);
        //CheckAndAddIntNode(Graph, IntNodeVals, DVal);
    }

      // add edge and edge attributes
    Graph->AddEdge(SVal, DVal, CurrRowIdx);

                // Aggregate edge attributes and add to graph
    for (TInt i = 0; i < EdgeAttrV.Len(); i++) {
      TStr ColName = EdgeAttrV[i];
      TAttrType T = Table->GetColType(ColName);
      TInt Index = Table->GetColIdx(ColName);
      switch (T) {
        case atInt:
          Graph->AddIntAttrDatE(CurrRowIdx, Table->IntCols[Index][CurrRowIdx], ColName);
          break;
        case atFlt:
          Graph->AddFltAttrDatE(CurrRowIdx, Table->FltCols[Index][CurrRowIdx], ColName);
          break;
        case atStr:
          Graph->AddStrAttrDatE(CurrRowIdx, Table->GetStrValIdx(Index, CurrRowIdx), ColName);
          break;
      }
    }
  }
  return Graph;

}

template<class PGraph >

PGraph TSnap::ToNetwork	(	PTable	Table,
		const TStr &	SrcCol,
		const TStr &	DstCol,
		TStrV &	EdgeAttrV,
		PTable	NodeTable,
		const TStr &	NodeCol,
		TStrV &	NodeAttrV,
		TAttrAggr	AggrPolicy
	)

Converts table to network sequentially. Takes edges from Table and nodes explicitly from NodeCol in NodeTable, with attribute vectors passed as columns in corresponding tables.

Definition at line 2010 of file conv.h.

                        {
  PGraph Graph = PGraph::TObj::New();

  const TAttrType NodeType = Table->GetColType(SrcCol);
  Assert(NodeType == Table->GetColType(DstCol));
  const TInt SrcColIdx = Table->GetColIdx(SrcCol);
  const TInt DstColIdx = Table->GetColIdx(DstCol);


  const TAttrType NodeTypeN = NodeTable->GetColType(NodeCol);
  const TInt NodeColIdx = NodeTable->GetColIdx(NodeCol);
  THash<TInt, TStrIntVH> NodeIntAttrs;
  THash<TInt, TStrFltVH> NodeFltAttrs;
  THash<TInt, TStrStrVH> NodeStrAttrs;


        //Table->AddGraphAttributeV(SrcAttrV, false, true, false);
        //Table->AddGraphAttributeV(DstAttrV, false, false, true);
        //Table->AddGraphAttributeV(EdgeAttrV, true, false, true);

  // node values - i.e. the unique values of src/dst col
  //THashSet<TInt> IntNodeVals; // for both int and string node attr types.
  THash<TFlt, TInt> FltNodeVals;

  // make single pass over all rows in the table
  for (int CurrRowIdx = 0; CurrRowIdx < (Table->Next).Len(); CurrRowIdx++) {
    if ((Table->Next)[CurrRowIdx] == Table->Invalid) {
      continue;
    }

    // add src and dst nodes to graph if they are not seen earlier
    TInt SVal, DVal;
    if (NodeType == atFlt) {
      TFlt FSVal = (Table->FltCols)[SrcColIdx][CurrRowIdx];
      SVal = Table->CheckAndAddFltNode(Graph, FltNodeVals, FSVal);
      TFlt FDVal = (Table->FltCols)[SrcColIdx][CurrRowIdx];
      DVal = Table->CheckAndAddFltNode(Graph, FltNodeVals, FDVal);
    }
    else if (NodeType == atInt || NodeType == atStr) {
      if (NodeType == atInt) {
        SVal = (Table->IntCols)[SrcColIdx][CurrRowIdx];
        DVal = (Table->IntCols)[DstColIdx][CurrRowIdx];
      }
      else {
        SVal = (Table->StrColMaps)[SrcColIdx][CurrRowIdx];
  //        if (strlen(Table->GetContextKey(SVal)) == 0) { continue; }  //illegal value
        DVal = (Table->StrColMaps)[DstColIdx][CurrRowIdx];
  //        if (strlen(Table->GetContextKey(DVal)) == 0) { continue; }  //illegal value
      }
      if (!Graph->IsNode(SVal)) {Graph->AddNode(SVal); }
      if (!Graph->IsNode(DVal)) {Graph->AddNode(DVal); }
        //CheckAndAddIntNode(Graph, IntNodeVals, SVal);
        //CheckAndAddIntNode(Graph, IntNodeVals, DVal);
    }

      // add edge and edge attributes
    Graph->AddEdge(SVal, DVal, CurrRowIdx);

                // Aggregate edge attributes and add to graph
    for (TInt i = 0; i < EdgeAttrV.Len(); i++) {
      TStr ColName = EdgeAttrV[i];
      TAttrType T = Table->GetColType(ColName);
      TInt Index = Table->GetColIdx(ColName);
      switch (T) {
        case atInt:
          Graph->AddIntAttrDatE(CurrRowIdx, Table->IntCols[Index][CurrRowIdx], ColName);
          break;
        case atFlt:
          Graph->AddFltAttrDatE(CurrRowIdx, Table->FltCols[Index][CurrRowIdx], ColName);
          break;
        case atStr:
          Graph->AddStrAttrDatE(CurrRowIdx, Table->GetStrValIdx(Index, CurrRowIdx), ColName);
          break;
      }
    }
  }


  //Add node attribtes
  if (NodeAttrV.Len() > 0) {
    for (int CurrRowIdx = 0; CurrRowIdx < (NodeTable->Next).Len(); CurrRowIdx++) {
      if ((NodeTable->Next)[CurrRowIdx] == NodeTable->Invalid) {
        continue;
      }
      TInt NId;
      if (NodeTypeN == atInt) {
        NId = (NodeTable->IntCols)[NodeColIdx][CurrRowIdx];
      }
      else if (NodeTypeN == atStr){
        NId = (NodeTable->StrColMaps)[NodeColIdx][CurrRowIdx];
      }
      for (TInt i = 0; i < NodeAttrV.Len(); i++) {
        TStr ColName = NodeAttrV[i];
        TAttrType T = NodeTable->GetColType(ColName);
        TInt Index = NodeTable->GetColIdx(ColName);
        switch (T) {
          case atInt:
            Graph->AddIntAttrDatN(NId, NodeTable->IntCols[Index][CurrRowIdx], ColName);
            break;
          case atFlt:
            Graph->AddFltAttrDatN(NId, NodeTable->FltCols[Index][CurrRowIdx], ColName);
            break;
          case atStr:
            Graph->AddStrAttrDatN(NId, NodeTable->GetStrValIdx(Index, CurrRowIdx), ColName);
            break;
        }
      }
    }
  }

  return Graph;

}

template<class PGraphMP >

PGraphMP TSnap::ToNetworkMP ( PTable  Table, const TStr &  SrcCol, const TStr &  DstCol, TStrV &  SrcAttrV, TStrV &  DstAttrV, TStrV &  EdgeAttrV, TAttrAggr  AggrPolicy  )

inline

Does Table to Network conversion in parallel using the sort-first algorithm. This is the recommended method to use.

Definition at line 696 of file conv.h.

                        {
  TStopwatch* Sw = TStopwatch::GetInstance();

  Sw->Start(TStopwatch::AllocateColumnCopies);
  const TInt SrcColIdx = Table->GetColIdx(SrcCol);
  const TInt DstColIdx = Table->GetColIdx(DstCol);
  const TInt NumRows = Table->GetNumValidRows();

  const TAttrType NodeType = Table->GetColType(SrcCol);
  Assert(NodeType == Table->GetColType(DstCol));


  TIntV SrcCol1, EdgeCol1, EdgeCol2, DstCol2;

  THash<TInt, TStrIntVH> NodeIntAttrs;
  THash<TInt, TStrFltVH> NodeFltAttrs;
  THash<TInt, TStrStrVH> NodeStrAttrs;

  #pragma omp parallel sections num_threads(4)
  {
    #pragma omp section
    { SrcCol1.Reserve(NumRows, NumRows); }
    #pragma omp section
    { EdgeCol1.Reserve(NumRows, NumRows); }
    #pragma omp section
    { DstCol2.Reserve(NumRows, NumRows); }
    #pragma omp section
    { EdgeCol2.Reserve(NumRows, NumRows); }
  }
  Sw->Stop(TStopwatch::AllocateColumnCopies);

  Sw->Start(TStopwatch::CopyColumns);
  TIntPrV Partitions;
  Table->GetPartitionRanges(Partitions, omp_get_max_threads());
  TInt PartitionSize = Partitions[0].GetVal2()-Partitions[0].GetVal1()+1;

  // double endPartition = omp_get_wtime();
  // printf("Partition time = %f\n", endPartition-endResize);

  omp_set_num_threads(omp_get_max_threads());
  if (NodeType == atInt) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx();
        SrcCol1[RowId] = RowI.GetIntAttr(SrcColIdx);
        EdgeCol1[RowId] = RowId;
        DstCol2[RowId] = RowI.GetIntAttr(DstColIdx);
        EdgeCol2[RowId] = RowId;
        RowI++;
      }
    }
  }
  else if (NodeType == atStr) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx();
        SrcCol1[RowId] = RowI.GetStrMapById(SrcColIdx);
        EdgeCol1[RowId] = RowId;
        DstCol2[RowId] = RowI.GetStrMapById(DstColIdx);
        EdgeCol2[RowId] = RowId;
        RowI++;
      }
    }
  }
  Sw->Stop(TStopwatch::CopyColumns);

  Sw->Start(TStopwatch::Sort);
  omp_set_num_threads(omp_get_max_threads());
  #pragma omp parallel
  {
    #pragma omp single nowait
    {
      #ifndef GLib_WIN32
      #pragma omp task untied shared(SrcCol1, EdgeCol1)
      #endif
      { TTable::QSortKeyVal(SrcCol1, EdgeCol1, 0, NumRows-1); }
    }
    #pragma omp single nowait
    {
      #ifndef GLib_WIN32
      #pragma omp task untied shared(EdgeCol2, DstCol2)
      #endif
     { TTable::QSortKeyVal(DstCol2, EdgeCol2, 0, NumRows-1); }
    }
    #ifndef GLib_WIN32
    #pragma omp taskwait
    #endif
  }
  Sw->Stop(TStopwatch::Sort);

  Sw->Start(TStopwatch::Group);
  TInt NumThreads = omp_get_max_threads();
  TInt PartSize = (NumRows/NumThreads);

  // Find the offset of all partitions, each of which contains a list of rows.
  // Nodes from same sources or destinations are ensured to be kept within same partition.
  TIntV SrcOffsets, DstOffsets;
  SrcOffsets.Add(0);
  for (TInt i = 1; i < NumThreads; i++) {
    TInt CurrOffset = i * PartSize;
    while (CurrOffset < (i+1) * PartSize &&
          SrcCol1[CurrOffset-1] == SrcCol1[CurrOffset]) {
      // ensure that rows from the same sources are grouped together
      CurrOffset++;
    }
    if (CurrOffset < (i+1) * PartSize) { SrcOffsets.Add(CurrOffset); }
  }
  SrcOffsets.Add(NumRows);

  DstOffsets.Add(0);
  for (TInt i = 1; i < NumThreads; i++) {
    TInt CurrOffset = i * PartSize;
    while (CurrOffset < (i+1) * PartSize &&
          DstCol2[CurrOffset-1] == DstCol2[CurrOffset]) {
      // ensure that rows to the same destinations are grouped together
      CurrOffset++;
    }
    if (CurrOffset < (i+1) * PartSize) { DstOffsets.Add(CurrOffset); }
  }
  DstOffsets.Add(NumRows);

  TInt SrcPartCnt = SrcOffsets.Len()-1; // number of partitions
  TInt DstPartCnt = DstOffsets.Len()-1; // number of partitions

  // count the number of source nodes and destination nodes in each partition
  TIntV SrcNodeCounts, DstNodeCounts;
  SrcNodeCounts.Reserve(SrcPartCnt, SrcPartCnt);
  DstNodeCounts.Reserve(DstPartCnt, DstPartCnt);

  #pragma omp parallel for schedule(dynamic)
  for (int t = 0; t < SrcPartCnt+DstPartCnt; t++) {
    if (t < SrcPartCnt) {
      TInt i = t;
      if (SrcOffsets[i] != SrcOffsets[i+1]) {
        SrcNodeCounts[i] = 1;
        TInt CurrNode = SrcCol1[SrcOffsets[i]];
        for (TInt j = SrcOffsets[i]+1; j < SrcOffsets[i+1]; j++) {
          while (j < SrcOffsets[i+1] && SrcCol1[j] == CurrNode) { j++; }
          if (j < SrcOffsets[i+1]) {
            SrcNodeCounts[i]++;
            CurrNode = SrcCol1[j];
          }
        }
      }
    } else {
      TInt i = t - SrcPartCnt;
      if (DstOffsets[i] != DstOffsets[i+1]) {
        DstNodeCounts[i] = 1;
        TInt CurrNode = DstCol2[DstOffsets[i]];
        for (TInt j = DstOffsets[i]+1; j < DstOffsets[i+1]; j++) {
          while (j < DstOffsets[i+1] && DstCol2[j] == CurrNode) { j++; }
          if (j < DstOffsets[i+1]) {
            DstNodeCounts[i]++;
            CurrNode = DstCol2[j];
          }
        }
      }
    }
  }

  TInt TotalSrcNodes = 0;
  TIntV SrcIdOffsets;
  for (int i = 0; i < SrcPartCnt; i++) {
    SrcIdOffsets.Add(TotalSrcNodes);
    TotalSrcNodes += SrcNodeCounts[i];
  }

  TInt TotalDstNodes = 0;
  TIntV DstIdOffsets;
  for (int i = 0; i < DstPartCnt; i++) {
    DstIdOffsets.Add(TotalDstNodes);
    TotalDstNodes += DstNodeCounts[i];
  }

  // printf("Total Src = %d, Total Dst = %d\n", TotalSrcNodes.Val, TotalDstNodes.Val);

  // find vector of (node_id, start_offset) where start_offset is the index of the first row with node_id
  TIntPrV SrcNodeIds, DstNodeIds;
  #pragma omp parallel sections
  {
    #pragma omp section
    { SrcNodeIds.Reserve(TotalSrcNodes, TotalSrcNodes); }
    #pragma omp section
    { DstNodeIds.Reserve(TotalDstNodes, TotalDstNodes); }
  }

  // Find the starting offset of each node (in both src and dst)
  #pragma omp parallel for schedule(dynamic)
  for (int t = 0; t < SrcPartCnt+DstPartCnt; t++) {
    if (t < SrcPartCnt) {
      TInt i = t;
      if (SrcOffsets[i] != SrcOffsets[i+1]) {
        TInt CurrNode = SrcCol1[SrcOffsets[i]];
        TInt ThreadOffset = SrcIdOffsets[i];
        SrcNodeIds[ThreadOffset] = TIntPr(CurrNode, SrcOffsets[i]);
        TInt CurrCount = 1;
        for (TInt j = SrcOffsets[i]+1; j < SrcOffsets[i+1]; j++) {
          while (j < SrcOffsets[i+1] && SrcCol1[j] == CurrNode) { j++; }
          if (j < SrcOffsets[i+1]) {
            CurrNode = SrcCol1[j];
            SrcNodeIds[ThreadOffset+CurrCount] = TIntPr(CurrNode, j);
            CurrCount++;
          }
        }
      }
    } else {
      TInt i = t - SrcPartCnt;
      if (DstOffsets[i] != DstOffsets[i+1]) {
        TInt CurrNode = DstCol2[DstOffsets[i]];
        TInt ThreadOffset = DstIdOffsets[i];
        DstNodeIds[ThreadOffset] = TIntPr(CurrNode, DstOffsets[i]);
        TInt CurrCount = 1;
        for (TInt j = DstOffsets[i]+1; j < DstOffsets[i+1]; j++) {
          while (j < DstOffsets[i+1] && DstCol2[j] == CurrNode) { j++; }
          if (j < DstOffsets[i+1]) {
            CurrNode = DstCol2[j];
            DstNodeIds[ThreadOffset+CurrCount] = TIntPr(CurrNode, j);
            CurrCount++;
          }
        }
      }
    }
  }
  Sw->Stop(TStopwatch::Group);

  Sw->Start(TStopwatch::MergeNeighborhoods);
  // Find the combined neighborhood (both out-neighbors and in-neighbors) of each node
  TIntTrV Nodes;
  Nodes.Reserve(TotalSrcNodes+TotalDstNodes);

  TInt i = 0, j = 0;
  while (i < TotalSrcNodes && j < TotalDstNodes) {
    if (SrcNodeIds[i].Val1 == DstNodeIds[j].Val1) {
      Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, j));
      i++;
      j++;
    } else if (SrcNodeIds[i].Val1 < DstNodeIds[j].Val1) {
      Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, -1));
      i++;
    } else {
      Nodes.Add(TIntTr(DstNodeIds[j].Val1, -1, j));
      j++;
    }
  }
  for (; i < TotalSrcNodes; i++) { Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, -1)); }
  for (; j < TotalDstNodes; j++) { Nodes.Add(TIntTr(DstNodeIds[j].Val1, -1, j)); }
  Sw->Stop(TStopwatch::MergeNeighborhoods);

  Sw->Start(TStopwatch::AddNeighborhoods);
  TInt NumNodes = Nodes.Len();
  PGraphMP Graph = PGraphMP::TObj::New(NumNodes, NumRows);
//  NumThreads = omp_get_max_threads();
//  int Delta = (NumNodes+NumThreads-1)/NumThreads;

  TVec<TIntV> InVV(NumNodes);
  TVec<TIntV> OutVV(NumNodes);

//  omp_set_num_threads(NumThreads);
  #pragma omp parallel for schedule(static,100)
  for (int m = 0; m < NumNodes; m++) {
    //double startTr = omp_get_wtime();
    //TIntV OutV, InV;
    TInt n, i, j;
    Nodes[m].GetVal(n, i, j);
    if (i >= 0) {
      TInt Offset = SrcNodeIds[i].GetVal2();
      TInt Sz = EdgeCol1.Len()-Offset;
      if (i < SrcNodeIds.Len()-1) { Sz = SrcNodeIds[i+1].GetVal2()-Offset; }
      OutVV[m].Reserve(Sz);
      OutVV[m].CopyUniqueFrom(EdgeCol1, Offset, Sz);
    }
    if (j >= 0) {
      TInt Offset = DstNodeIds[j].GetVal2();
      TInt Sz = EdgeCol2.Len()-Offset;
      if (j < DstNodeIds.Len()-1) { Sz = DstNodeIds[j+1].GetVal2()-Offset; }
      InVV[m].Reserve(Sz);
      InVV[m].CopyUniqueFrom(EdgeCol2, Offset, Sz);
    }
    Graph->AddNodeWithEdges(n, InVV[m], OutVV[m]);
  }
  Graph->SetNodes(NumNodes);
  Sw->Stop(TStopwatch::AddNeighborhoods);

  Sw->Start(TStopwatch::AddEdges);
  omp_set_num_threads(omp_get_max_threads());
  if (NodeType == atInt) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx(); // EdgeId
        TInt SrcId = RowI.GetIntAttr(SrcColIdx);
        TInt DstId = RowI.GetIntAttr(DstColIdx);
        Graph->AddEdgeUnchecked(RowId, SrcId, DstId);
        RowI++;
                for (TInt ea_i = 0; ea_i < EdgeAttrV.Len(); ea_i++) {
          TStr ColName = EdgeAttrV[ea_i];
          TAttrType T = Table->GetColType(ColName);
          TInt Index = Table->GetColIdx(ColName);
          switch (T) {
            case atInt:
              Graph->AddIntAttrDatE(RowId, Table->IntCols[Index][RowId], ColName);
              break;
            case atFlt:
              Graph->AddFltAttrDatE(RowId, Table->FltCols[Index][RowId], ColName);
              break;
            case atStr:
              Graph->AddStrAttrDatE(RowId, Table->GetStrValIdx(Index, RowId), ColName);
              break;
          }
        }
        if ((Table->SrcNodeAttrV).Len() > 0) {
          Table->AddNodeAttributes(SrcId, Table->SrcNodeAttrV, RowId, NodeIntAttrs, NodeFltAttrs, NodeStrAttrs);
        }

        if ((Table->DstNodeAttrV).Len() > 0) {
         Table->AddNodeAttributes(SrcId, Table->DstNodeAttrV, RowId, NodeIntAttrs, NodeFltAttrs, NodeStrAttrs);
        }
      }
    }
  }
  else if (NodeType == atStr) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx(); // EdgeId
        TInt SrcId = RowI.GetStrMapById(SrcColIdx);
        TInt DstId = RowI.GetStrMapById(DstColIdx);
        Graph->AddEdgeUnchecked(RowId, SrcId, DstId);
        RowI++;
                for (TInt ea_i = 0; ea_i < EdgeAttrV.Len(); ea_i++) {
          TStr ColName = EdgeAttrV[ea_i];
          TAttrType T = Table->GetColType(ColName);
          TInt Index = Table->GetColIdx(ColName);
          switch (T) {
            case atInt:
              Graph->AddIntAttrDatE(RowId, Table->IntCols[Index][RowId], ColName);
              break;
            case atFlt:
              Graph->AddFltAttrDatE(RowId, Table->FltCols[Index][RowId], ColName);
              break;
            case atStr:
              Graph->AddStrAttrDatE(RowId, Table->GetStrValIdx(Index, RowId), ColName);
              break;
          }
        }
        if ((Table->SrcNodeAttrV).Len() > 0) {
          Table->AddNodeAttributes(SrcId, Table->SrcNodeAttrV, RowId, NodeIntAttrs, NodeFltAttrs, NodeStrAttrs);
        }

        if ((Table->DstNodeAttrV).Len() > 0) {
         Table->AddNodeAttributes(SrcId, Table->DstNodeAttrV, RowId, NodeIntAttrs, NodeFltAttrs, NodeStrAttrs);
        }

      }
    }

  }

  // aggregate node attributes and add to graph
  if ((Table->SrcNodeAttrV).Len() > 0 || (Table->DstNodeAttrV).Len() > 0) {
    for (typename PGraphMP::TObj::TNodeI NodeI = Graph->BegNI(); NodeI < Graph->EndNI(); NodeI++) {
      TInt NId = NodeI.GetId();
      if (NodeIntAttrs.IsKey(NId)) {
        TStrIntVH IntAttrVals = NodeIntAttrs.GetDat(NId);
        for (TStrIntVH::TIter it = IntAttrVals.BegI(); it < IntAttrVals.EndI(); it++) {
          TInt AttrVal = Table->AggregateVector<TInt>(it.GetDat(), AggrPolicy);
          Graph->AddIntAttrDatN(NId, AttrVal, it.GetKey());
        }
      }
      if (NodeFltAttrs.IsKey(NId)) {
        TStrFltVH FltAttrVals = NodeFltAttrs.GetDat(NId);
        for (TStrFltVH::TIter it = FltAttrVals.BegI(); it < FltAttrVals.EndI(); it++) {
          TFlt AttrVal = Table->AggregateVector<TFlt>(it.GetDat(), AggrPolicy);
          Graph->AddFltAttrDatN(NId, AttrVal, it.GetKey());
        }
      }
      if (NodeStrAttrs.IsKey(NId)) {
        TStrStrVH StrAttrVals = NodeStrAttrs.GetDat(NId);
        for (TStrStrVH::TIter it = StrAttrVals.BegI(); it < StrAttrVals.EndI(); it++) {
          TStr AttrVal = Table->AggregateVector<TStr>(it.GetDat(), AggrPolicy);
          Graph->AddStrAttrDatN(NId, AttrVal, it.GetKey());
        }
      }
    }
  }


  Graph->SetEdges(NumRows);
  Sw->Stop(TStopwatch::AddEdges);

  // double endAdd = omp_get_wtime();
  // printf("Add time = %f\n", endAdd-endAlloc);

  return Graph;
}

template<class PGraphMP >

PGraphMP TSnap::ToNetworkMP	(	PTable	Table,
		const TStr &	SrcCol,
		const TStr &	DstCol,
		TAttrAggr	AggrPolicy
	)

Calls ToNetworkMP with empty attribute vector. Convenience wrapper.

Definition at line 1107 of file conv.h.

{
  TStrV V;
  return ToNetworkMP<PGraphMP>(Table, SrcCol, DstCol, V,AggrPolicy);
}

template<class PGraphMP >

PGraphMP TSnap::ToNetworkMP ( PTable  Table, const TStr &  SrcCol, const TStr &  DstCol, TStrV &  EdgeAttrV, TAttrAggr  AggrPolicy  )

inline

Converts table to network in parallel. Use if network has only edge attributes.

Definition at line 1651 of file conv.h.

                        {
  TStopwatch* Sw = TStopwatch::GetInstance();

  Sw->Start(TStopwatch::AllocateColumnCopies);
  const TInt SrcColIdx = Table->GetColIdx(SrcCol);
  const TInt DstColIdx = Table->GetColIdx(DstCol);
  const TInt NumRows = Table->GetNumValidRows();

  const TAttrType NodeType = Table->GetColType(SrcCol);
  Assert(NodeType == Table->GetColType(DstCol));

  TIntV SrcCol1, EdgeCol1, EdgeCol2, DstCol2;

  THash<TInt, TStrIntVH> NodeIntAttrs;
  THash<TInt, TStrFltVH> NodeFltAttrs;
  THash<TInt, TStrStrVH> NodeStrAttrs;

  #pragma omp parallel sections num_threads(4)
  {
    #pragma omp section
    { SrcCol1.Reserve(NumRows, NumRows); }
    #pragma omp section
    { EdgeCol1.Reserve(NumRows, NumRows); }
    #pragma omp section
    { DstCol2.Reserve(NumRows, NumRows); }
    #pragma omp section
    { EdgeCol2.Reserve(NumRows, NumRows); }
  }
  Sw->Stop(TStopwatch::AllocateColumnCopies);

  Sw->Start(TStopwatch::CopyColumns);
  TIntPrV Partitions;
  Table->GetPartitionRanges(Partitions, omp_get_max_threads());
  TInt PartitionSize = Partitions[0].GetVal2()-Partitions[0].GetVal1()+1;


  // double endPartition = omp_get_wtime();
  // printf("Partition time = %f\n", endPartition-endResize);

  omp_set_num_threads(omp_get_max_threads());
  if (NodeType == atInt) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx();
        SrcCol1[RowId] = RowI.GetIntAttr(SrcColIdx);
        EdgeCol1[RowId] = RowId;
        DstCol2[RowId] = RowI.GetIntAttr(DstColIdx);
        EdgeCol2[RowId] = RowId;
        RowI++;
      }
    }
  }
  else if (NodeType == atStr) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx();
        SrcCol1[RowId] = RowI.GetStrMapById(SrcColIdx);
        EdgeCol1[RowId] = RowId;
        DstCol2[RowId] = RowI.GetStrMapById(DstColIdx);
        EdgeCol2[RowId] = RowId;
        RowI++;
     }
    }
  }
  Sw->Stop(TStopwatch::CopyColumns);

  Sw->Start(TStopwatch::Sort);
  omp_set_num_threads(omp_get_max_threads());
  #pragma omp parallel
  {
    #pragma omp single nowait
    {
      #ifndef GLib_WIN32
      #pragma omp task untied shared(SrcCol1, EdgeCol1)
      #endif
      { TTable::QSortKeyVal(SrcCol1, EdgeCol1, 0, NumRows-1); }
    }
    #pragma omp single nowait
    {
      #ifndef GLib_WIN32
      #pragma omp task untied shared(EdgeCol2, DstCol2)
      #endif
     { TTable::QSortKeyVal(DstCol2, EdgeCol2, 0, NumRows-1); }
    }
    #ifndef GLib_WIN32
    #pragma omp taskwait
    #endif
  }
  Sw->Stop(TStopwatch::Sort);

  Sw->Start(TStopwatch::Group);
  TInt NumThreads = omp_get_max_threads();
  TInt PartSize = (NumRows/NumThreads);

  // Find the offset of all partitions, each of which contains a list of rows.
  // Nodes from same sources or destinations are ensured to be kept within same partition.
  TIntV SrcOffsets, DstOffsets;
  SrcOffsets.Add(0);
  for (TInt i = 1; i < NumThreads; i++) {
    TInt CurrOffset = i * PartSize;
    while (CurrOffset < (i+1) * PartSize &&
          SrcCol1[CurrOffset-1] == SrcCol1[CurrOffset]) {
      // ensure that rows from the same sources are grouped together
      CurrOffset++;
    }
    if (CurrOffset < (i+1) * PartSize) { SrcOffsets.Add(CurrOffset); }
  }
  SrcOffsets.Add(NumRows);

  DstOffsets.Add(0);
  for (TInt i = 1; i < NumThreads; i++) {
    TInt CurrOffset = i * PartSize;
    while (CurrOffset < (i+1) * PartSize &&
          DstCol2[CurrOffset-1] == DstCol2[CurrOffset]) {
      // ensure that rows to the same destinations are grouped together
      CurrOffset++;
    }
    if (CurrOffset < (i+1) * PartSize) { DstOffsets.Add(CurrOffset); }
  }
  DstOffsets.Add(NumRows);

  TInt SrcPartCnt = SrcOffsets.Len()-1; // number of partitions
  TInt DstPartCnt = DstOffsets.Len()-1; // number of partitions

  // count the number of source nodes and destination nodes in each partition
  TIntV SrcNodeCounts, DstNodeCounts;
  SrcNodeCounts.Reserve(SrcPartCnt, SrcPartCnt);
  DstNodeCounts.Reserve(DstPartCnt, DstPartCnt);

  #pragma omp parallel for schedule(dynamic)
  for (int t = 0; t < SrcPartCnt+DstPartCnt; t++) {
    if (t < SrcPartCnt) {
      TInt i = t;
      if (SrcOffsets[i] != SrcOffsets[i+1]) {
        SrcNodeCounts[i] = 1;
        TInt CurrNode = SrcCol1[SrcOffsets[i]];
        for (TInt j = SrcOffsets[i]+1; j < SrcOffsets[i+1]; j++) {
          while (j < SrcOffsets[i+1] && SrcCol1[j] == CurrNode) { j++; }
          if (j < SrcOffsets[i+1]) {
            SrcNodeCounts[i]++;
            CurrNode = SrcCol1[j];
          }
        }
      }
    } else {
      TInt i = t - SrcPartCnt;
      if (DstOffsets[i] != DstOffsets[i+1]) {
        DstNodeCounts[i] = 1;
        TInt CurrNode = DstCol2[DstOffsets[i]];
        for (TInt j = DstOffsets[i]+1; j < DstOffsets[i+1]; j++) {
          while (j < DstOffsets[i+1] && DstCol2[j] == CurrNode) { j++; }
          if (j < DstOffsets[i+1]) {
            DstNodeCounts[i]++;
            CurrNode = DstCol2[j];
          }
        }
      }
    }
  }

  TInt TotalSrcNodes = 0;
  TIntV SrcIdOffsets;
  for (int i = 0; i < SrcPartCnt; i++) {
    SrcIdOffsets.Add(TotalSrcNodes);
    TotalSrcNodes += SrcNodeCounts[i];
  }

  TInt TotalDstNodes = 0;
  TIntV DstIdOffsets;
  for (int i = 0; i < DstPartCnt; i++) {
    DstIdOffsets.Add(TotalDstNodes);
    TotalDstNodes += DstNodeCounts[i];
  }

  // printf("Total Src = %d, Total Dst = %d\n", TotalSrcNodes.Val, TotalDstNodes.Val);

  // find vector of (node_id, start_offset) where start_offset is the index of the first row with node_id
  TIntPrV SrcNodeIds, DstNodeIds;
  #pragma omp parallel sections
  {
    #pragma omp section
    { SrcNodeIds.Reserve(TotalSrcNodes, TotalSrcNodes); }
    #pragma omp section
    { DstNodeIds.Reserve(TotalDstNodes, TotalDstNodes); }
  }

  // Find the starting offset of each node (in both src and dst)
  #pragma omp parallel for schedule(dynamic)
  for (int t = 0; t < SrcPartCnt+DstPartCnt; t++) {
    if (t < SrcPartCnt) {
      TInt i = t;
      if (SrcOffsets[i] != SrcOffsets[i+1]) {
        TInt CurrNode = SrcCol1[SrcOffsets[i]];
        TInt ThreadOffset = SrcIdOffsets[i];
        SrcNodeIds[ThreadOffset] = TIntPr(CurrNode, SrcOffsets[i]);
        TInt CurrCount = 1;
        for (TInt j = SrcOffsets[i]+1; j < SrcOffsets[i+1]; j++) {
          while (j < SrcOffsets[i+1] && SrcCol1[j] == CurrNode) { j++; }
          if (j < SrcOffsets[i+1]) {
            CurrNode = SrcCol1[j];
            SrcNodeIds[ThreadOffset+CurrCount] = TIntPr(CurrNode, j);
            CurrCount++;
          }
        }
      }
    } else {
      TInt i = t - SrcPartCnt;
      if (DstOffsets[i] != DstOffsets[i+1]) {
        TInt CurrNode = DstCol2[DstOffsets[i]];
        TInt ThreadOffset = DstIdOffsets[i];
        DstNodeIds[ThreadOffset] = TIntPr(CurrNode, DstOffsets[i]);
        TInt CurrCount = 1;
        for (TInt j = DstOffsets[i]+1; j < DstOffsets[i+1]; j++) {
          while (j < DstOffsets[i+1] && DstCol2[j] == CurrNode) { j++; }
          if (j < DstOffsets[i+1]) {
            CurrNode = DstCol2[j];
            DstNodeIds[ThreadOffset+CurrCount] = TIntPr(CurrNode, j);
            CurrCount++;
          }
        }
      }
    }
  }
  Sw->Stop(TStopwatch::Group);

  Sw->Start(TStopwatch::MergeNeighborhoods);
  // Find the combined neighborhood (both out-neighbors and in-neighbors) of each node
  TIntTrV Nodes;
  Nodes.Reserve(TotalSrcNodes+TotalDstNodes);

  TInt i = 0, j = 0;
  while (i < TotalSrcNodes && j < TotalDstNodes) {
    if (SrcNodeIds[i].Val1 == DstNodeIds[j].Val1) {
      Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, j));
      i++;
      j++;
    } else if (SrcNodeIds[i].Val1 < DstNodeIds[j].Val1) {
      Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, -1));
      i++;
    } else {
      Nodes.Add(TIntTr(DstNodeIds[j].Val1, -1, j));
      j++;
    }
  }
  for (; i < TotalSrcNodes; i++) { Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, -1)); }
  for (; j < TotalDstNodes; j++) { Nodes.Add(TIntTr(DstNodeIds[j].Val1, -1, j)); }
  Sw->Stop(TStopwatch::MergeNeighborhoods);

  Sw->Start(TStopwatch::AddNeighborhoods);
  TInt NumNodes = Nodes.Len();
  PGraphMP Graph = PGraphMP::TObj::New(NumNodes, NumRows);
//  NumThreads = omp_get_max_threads();
//  int Delta = (NumNodes+NumThreads-1)/NumThreads;

  TVec<TIntV> InVV(NumNodes);
  TVec<TIntV> OutVV(NumNodes);

//  omp_set_num_threads(NumThreads);
  #pragma omp parallel for schedule(static,100)
  for (int m = 0; m < NumNodes; m++) {
    //double startTr = omp_get_wtime();
    //TIntV OutV, InV;
    TInt n, i, j;
    Nodes[m].GetVal(n, i, j);
    if (i >= 0) {
      TInt Offset = SrcNodeIds[i].GetVal2();
      TInt Sz = EdgeCol1.Len()-Offset;
      if (i < SrcNodeIds.Len()-1) { Sz = SrcNodeIds[i+1].GetVal2()-Offset; }
      OutVV[m].Reserve(Sz);
      OutVV[m].CopyUniqueFrom(EdgeCol1, Offset, Sz);
    }
    if (j >= 0) {
      TInt Offset = DstNodeIds[j].GetVal2();
      TInt Sz = EdgeCol2.Len()-Offset;
      if (j < DstNodeIds.Len()-1) { Sz = DstNodeIds[j+1].GetVal2()-Offset; }
      InVV[m].Reserve(Sz);
      InVV[m].CopyUniqueFrom(EdgeCol2, Offset, Sz);
    }
    Graph->AddNodeWithEdges(n, InVV[m], OutVV[m]);
  }
  Graph->SetNodes(NumNodes);
  Sw->Stop(TStopwatch::AddNeighborhoods);

  Sw->Start(TStopwatch::AddEdges);
  omp_set_num_threads(omp_get_max_threads());
  if (NodeType == atInt) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx(); // EdgeId
        TInt SrcId = RowI.GetIntAttr(SrcColIdx);
        TInt DstId = RowI.GetIntAttr(DstColIdx);
        Graph->AddEdgeUnchecked(RowId, SrcId, DstId);
        RowI++;
      }
    }
  }
  else if (NodeType == atStr) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx(); // EdgeId
        TInt SrcId = RowI.GetStrMapById(SrcColIdx);
        TInt DstId = RowI.GetStrMapById(DstColIdx);
        Graph->AddEdgeUnchecked(RowId, SrcId, DstId);
        RowI++;
      }
    }

  }

  Graph->SetEdges(NumRows);
  Graph->SetMxEId(NumRows);
  Sw->Stop(TStopwatch::AddEdges);

  // make single pass over all rows in the table to add attributes
  for (int CurrRowIdx = 0; CurrRowIdx < (Table->Next).Len(); CurrRowIdx++) {
    if ((Table->Next)[CurrRowIdx] == Table->Invalid) {
      continue;
    }
    for (TInt ea_i = 0; ea_i < EdgeAttrV.Len(); ea_i++) {
      TStr ColName = EdgeAttrV[ea_i];
      TAttrType T = Table->GetColType(ColName);
      TInt Index = Table->GetColIdx(ColName);
      switch (T) {
        case atInt:
          Graph->AddIntAttrDatE(CurrRowIdx, Table->IntCols[Index][CurrRowIdx], ColName);
          break;
        case atFlt:
          Graph->AddFltAttrDatE(CurrRowIdx, Table->FltCols[Index][CurrRowIdx], ColName);
          break;
        case atStr:
          Graph->AddStrAttrDatE(CurrRowIdx, Table->GetStrValIdx(Index, CurrRowIdx), ColName);
          break;
      }
    }
  }
  // double endAdd = omp_get_wtime();
  // printf("Add time = %f\n", endAdd-endAlloc);

  return Graph;
}

template<class PGraphMP >

PGraphMP TSnap::ToNetworkMP ( PTable  Table, const TStr &  SrcCol, const TStr &  DstCol, TStrV &  EdgeAttrV, PTable  NodeTable, const TStr &  NodeCol, TStrV &  NodeAttrV, TAttrAggr  AggrPolicy  )

inline

Converts table to network in parallel. Takes edges from Table and nodes explicitly from NodeCol in NodeTable, with attribute vectors passed as columns in corresponding tables.

Definition at line 2131 of file conv.h.

                        {
  TStopwatch* Sw = TStopwatch::GetInstance();

  Sw->Start(TStopwatch::AllocateColumnCopies);
  const TInt SrcColIdx = Table->GetColIdx(SrcCol);
  const TInt DstColIdx = Table->GetColIdx(DstCol);
  const TInt NumRows = Table->GetNumValidRows();

  const TAttrType NodeType = Table->GetColType(SrcCol);
  Assert(NodeType == Table->GetColType(DstCol));


  TIntV SrcCol1, EdgeCol1, EdgeCol2, DstCol2;

  const TAttrType NodeTypeN = NodeTable->GetColType(NodeCol);
  const TInt NodeColIdx = NodeTable->GetColIdx(NodeCol);
  THash<TInt, TStrIntVH> NodeIntAttrs;
  THash<TInt, TStrFltVH> NodeFltAttrs;
  THash<TInt, TStrStrVH> NodeStrAttrs;

  #pragma omp parallel sections num_threads(4)
  {
    #pragma omp section
    { SrcCol1.Reserve(NumRows, NumRows); }
    #pragma omp section
    { EdgeCol1.Reserve(NumRows, NumRows); }
    #pragma omp section
    { DstCol2.Reserve(NumRows, NumRows); }
    #pragma omp section
    { EdgeCol2.Reserve(NumRows, NumRows); }
  }
  Sw->Stop(TStopwatch::AllocateColumnCopies);

  Sw->Start(TStopwatch::CopyColumns);
  TIntPrV Partitions;
  Table->GetPartitionRanges(Partitions, omp_get_max_threads());
  TInt PartitionSize = Partitions[0].GetVal2()-Partitions[0].GetVal1()+1;

  // double endPartition = omp_get_wtime();
  // printf("Partition time = %f\n", endPartition-endResize);

  omp_set_num_threads(omp_get_max_threads());
  if (NodeType == atInt) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx();
        SrcCol1[RowId] = RowI.GetIntAttr(SrcColIdx);
        EdgeCol1[RowId] = RowId;
        DstCol2[RowId] = RowI.GetIntAttr(DstColIdx);
        EdgeCol2[RowId] = RowId;
        RowI++;
      }
    }
  }
  else if (NodeType == atStr) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx();
        SrcCol1[RowId] = RowI.GetStrMapById(SrcColIdx);
        EdgeCol1[RowId] = RowId;
        DstCol2[RowId] = RowI.GetStrMapById(DstColIdx);
        EdgeCol2[RowId] = RowId;
        RowI++;
      }
    }
  }
  Sw->Stop(TStopwatch::CopyColumns);

  Sw->Start(TStopwatch::Sort);
  omp_set_num_threads(omp_get_max_threads());
  #pragma omp parallel
  {
    #pragma omp single nowait
    {
      #ifndef GLib_WIN32
      #pragma omp task untied shared(SrcCol1, EdgeCol1)
      #endif
      { TTable::QSortKeyVal(SrcCol1, EdgeCol1, 0, NumRows-1); }
    }
    #pragma omp single nowait
    {
      #ifndef GLib_WIN32
      #pragma omp task untied shared(EdgeCol2, DstCol2)
      #endif
     { TTable::QSortKeyVal(DstCol2, EdgeCol2, 0, NumRows-1); }
    }
    #ifndef GLib_WIN32
    #pragma omp taskwait
    #endif
  }
  Sw->Stop(TStopwatch::Sort);

  Sw->Start(TStopwatch::Group);
  TInt NumThreads = omp_get_max_threads();
  TInt PartSize = (NumRows/NumThreads);

  // Find the offset of all partitions, each of which contains a list of rows.
  // Nodes from same sources or destinations are ensured to be kept within same partition.
  TIntV SrcOffsets, DstOffsets;
  SrcOffsets.Add(0);
  for (TInt i = 1; i < NumThreads; i++) {
    TInt CurrOffset = i * PartSize;
    while (CurrOffset < (i+1) * PartSize &&
          SrcCol1[CurrOffset-1] == SrcCol1[CurrOffset]) {
      // ensure that rows from the same sources are grouped together
      CurrOffset++;
    }
    if (CurrOffset < (i+1) * PartSize) { SrcOffsets.Add(CurrOffset); }
  }
  SrcOffsets.Add(NumRows);

  DstOffsets.Add(0);
  for (TInt i = 1; i < NumThreads; i++) {
    TInt CurrOffset = i * PartSize;
    while (CurrOffset < (i+1) * PartSize &&
          DstCol2[CurrOffset-1] == DstCol2[CurrOffset]) {
      // ensure that rows to the same destinations are grouped together
      CurrOffset++;
    }
    if (CurrOffset < (i+1) * PartSize) { DstOffsets.Add(CurrOffset); }
  }
  DstOffsets.Add(NumRows);

  TInt SrcPartCnt = SrcOffsets.Len()-1; // number of partitions
  TInt DstPartCnt = DstOffsets.Len()-1; // number of partitions

  // count the number of source nodes and destination nodes in each partition
  TIntV SrcNodeCounts, DstNodeCounts;
  SrcNodeCounts.Reserve(SrcPartCnt, SrcPartCnt);
  DstNodeCounts.Reserve(DstPartCnt, DstPartCnt);

  #pragma omp parallel for schedule(dynamic)
  for (int t = 0; t < SrcPartCnt+DstPartCnt; t++) {
    if (t < SrcPartCnt) {
      TInt i = t;
      if (SrcOffsets[i] != SrcOffsets[i+1]) {
        SrcNodeCounts[i] = 1;
        TInt CurrNode = SrcCol1[SrcOffsets[i]];
        for (TInt j = SrcOffsets[i]+1; j < SrcOffsets[i+1]; j++) {
          while (j < SrcOffsets[i+1] && SrcCol1[j] == CurrNode) { j++; }
          if (j < SrcOffsets[i+1]) {
            SrcNodeCounts[i]++;
            CurrNode = SrcCol1[j];
          }
        }
      }
    } else {
      TInt i = t - SrcPartCnt;
      if (DstOffsets[i] != DstOffsets[i+1]) {
        DstNodeCounts[i] = 1;
        TInt CurrNode = DstCol2[DstOffsets[i]];
        for (TInt j = DstOffsets[i]+1; j < DstOffsets[i+1]; j++) {
          while (j < DstOffsets[i+1] && DstCol2[j] == CurrNode) { j++; }
          if (j < DstOffsets[i+1]) {
            DstNodeCounts[i]++;
            CurrNode = DstCol2[j];
          }
        }
      }
    }
  }

  TInt TotalSrcNodes = 0;
  TIntV SrcIdOffsets;
  for (int i = 0; i < SrcPartCnt; i++) {
    SrcIdOffsets.Add(TotalSrcNodes);
    TotalSrcNodes += SrcNodeCounts[i];
  }

  TInt TotalDstNodes = 0;
  TIntV DstIdOffsets;
  for (int i = 0; i < DstPartCnt; i++) {
    DstIdOffsets.Add(TotalDstNodes);
    TotalDstNodes += DstNodeCounts[i];
  }

  // printf("Total Src = %d, Total Dst = %d\n", TotalSrcNodes.Val, TotalDstNodes.Val);

  // find vector of (node_id, start_offset) where start_offset is the index of the first row with node_id
  TIntPrV SrcNodeIds, DstNodeIds;
  #pragma omp parallel sections
  {
    #pragma omp section
    { SrcNodeIds.Reserve(TotalSrcNodes, TotalSrcNodes); }
    #pragma omp section
    { DstNodeIds.Reserve(TotalDstNodes, TotalDstNodes); }
  }

  // Find the starting offset of each node (in both src and dst)
  #pragma omp parallel for schedule(dynamic)
  for (int t = 0; t < SrcPartCnt+DstPartCnt; t++) {
    if (t < SrcPartCnt) {
      TInt i = t;
      if (SrcOffsets[i] != SrcOffsets[i+1]) {
        TInt CurrNode = SrcCol1[SrcOffsets[i]];
        TInt ThreadOffset = SrcIdOffsets[i];
        SrcNodeIds[ThreadOffset] = TIntPr(CurrNode, SrcOffsets[i]);
        TInt CurrCount = 1;
        for (TInt j = SrcOffsets[i]+1; j < SrcOffsets[i+1]; j++) {
          while (j < SrcOffsets[i+1] && SrcCol1[j] == CurrNode) { j++; }
          if (j < SrcOffsets[i+1]) {
            CurrNode = SrcCol1[j];
            SrcNodeIds[ThreadOffset+CurrCount] = TIntPr(CurrNode, j);
            CurrCount++;
          }
        }
      }
    } else {
      TInt i = t - SrcPartCnt;
      if (DstOffsets[i] != DstOffsets[i+1]) {
        TInt CurrNode = DstCol2[DstOffsets[i]];
        TInt ThreadOffset = DstIdOffsets[i];
        DstNodeIds[ThreadOffset] = TIntPr(CurrNode, DstOffsets[i]);
        TInt CurrCount = 1;
        for (TInt j = DstOffsets[i]+1; j < DstOffsets[i+1]; j++) {
          while (j < DstOffsets[i+1] && DstCol2[j] == CurrNode) { j++; }
          if (j < DstOffsets[i+1]) {
            CurrNode = DstCol2[j];
            DstNodeIds[ThreadOffset+CurrCount] = TIntPr(CurrNode, j);
            CurrCount++;
          }
        }
      }
    }
  }
  Sw->Stop(TStopwatch::Group);

  Sw->Start(TStopwatch::MergeNeighborhoods);
  // Find the combined neighborhood (both out-neighbors and in-neighbors) of each node
  TIntTrV Nodes;
  Nodes.Reserve(TotalSrcNodes+TotalDstNodes);

  TInt i = 0, j = 0;
  while (i < TotalSrcNodes && j < TotalDstNodes) {
    if (SrcNodeIds[i].Val1 == DstNodeIds[j].Val1) {
      Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, j));
      i++;
      j++;
    } else if (SrcNodeIds[i].Val1 < DstNodeIds[j].Val1) {
      Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, -1));
      i++;
    } else {
      Nodes.Add(TIntTr(DstNodeIds[j].Val1, -1, j));
      j++;
    }
  }
  for (; i < TotalSrcNodes; i++) { Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, -1)); }
  for (; j < TotalDstNodes; j++) { Nodes.Add(TIntTr(DstNodeIds[j].Val1, -1, j)); }
  Sw->Stop(TStopwatch::MergeNeighborhoods);

  Sw->Start(TStopwatch::AddNeighborhoods);
  TInt NumNodes = Nodes.Len();
  PGraphMP Graph = PGraphMP::TObj::New(NumNodes, NumRows);
//  NumThreads = omp_get_max_threads();
//  int Delta = (NumNodes+NumThreads-1)/NumThreads;

  TVec<TIntV> InVV(NumNodes);
  TVec<TIntV> OutVV(NumNodes);

//  omp_set_num_threads(NumThreads);
  #pragma omp parallel for schedule(static,100)
  for (int m = 0; m < NumNodes; m++) {
    //double startTr = omp_get_wtime();
    //TIntV OutV, InV;
    TInt n, i, j;
    Nodes[m].GetVal(n, i, j);
    if (i >= 0) {
      TInt Offset = SrcNodeIds[i].GetVal2();
      TInt Sz = EdgeCol1.Len()-Offset;
      if (i < SrcNodeIds.Len()-1) { Sz = SrcNodeIds[i+1].GetVal2()-Offset; }
      OutVV[m].Reserve(Sz);
      OutVV[m].CopyUniqueFrom(EdgeCol1, Offset, Sz);
    }
    if (j >= 0) {
      TInt Offset = DstNodeIds[j].GetVal2();
      TInt Sz = EdgeCol2.Len()-Offset;
      if (j < DstNodeIds.Len()-1) { Sz = DstNodeIds[j+1].GetVal2()-Offset; }
      InVV[m].Reserve(Sz);
      InVV[m].CopyUniqueFrom(EdgeCol2, Offset, Sz);
    }
    Graph->AddNodeWithEdges(n, InVV[m], OutVV[m]);
  }
  Graph->SetNodes(NumNodes);
  Sw->Stop(TStopwatch::AddNeighborhoods);

  Sw->Start(TStopwatch::AddEdges);
  omp_set_num_threads(omp_get_max_threads());
  if (NodeType == atInt) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx(); // EdgeId
        TInt SrcId = RowI.GetIntAttr(SrcColIdx);
        TInt DstId = RowI.GetIntAttr(DstColIdx);
        Graph->AddEdgeUnchecked(RowId, SrcId, DstId);
        RowI++;
      }
    }
  }
  else if (NodeType == atStr) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx(); // EdgeId
        TInt SrcId = RowI.GetStrMapById(SrcColIdx);
        TInt DstId = RowI.GetStrMapById(DstColIdx);
        Graph->AddEdgeUnchecked(RowId, SrcId, DstId);
        RowI++;
      }
    }

  }

  Graph->SetEdges(NumRows);
  Graph->SetMxEId(NumRows);
  Sw->Stop(TStopwatch::AddEdges);

  // make single pass over all rows in the table to add attributes
  for (int CurrRowIdx = 0; CurrRowIdx < (Table->Next).Len(); CurrRowIdx++) {
    if ((Table->Next)[CurrRowIdx] == Table->Invalid) {
      continue;
    }
    for (TInt ea_i = 0; ea_i < EdgeAttrV.Len(); ea_i++) {
      TStr ColName = EdgeAttrV[ea_i];
      TAttrType T = Table->GetColType(ColName);
      TInt Index = Table->GetColIdx(ColName);
      switch (T) {
        case atInt:
          Graph->AddIntAttrDatE(CurrRowIdx, Table->IntCols[Index][CurrRowIdx], ColName);
          break;
        case atFlt:
          Graph->AddFltAttrDatE(CurrRowIdx, Table->FltCols[Index][CurrRowIdx], ColName);
          break;
        case atStr:
          Graph->AddStrAttrDatE(CurrRowIdx, Table->GetStrValIdx(Index, CurrRowIdx), ColName);
          break;
      }
    }
  }

  // Add node attribtes
  if (NodeAttrV.Len() > 0) {
    for (int CurrRowIdx = 0; CurrRowIdx < (NodeTable->Next).Len(); CurrRowIdx++) {
      if ((NodeTable->Next)[CurrRowIdx] == NodeTable->Invalid) {
        continue;
      }
      TInt NId;
      if (NodeTypeN == atInt) {
        NId = (NodeTable->IntCols)[NodeColIdx][CurrRowIdx];
      }
      else if (NodeTypeN == atStr){
        NId = (NodeTable->StrColMaps)[NodeColIdx][CurrRowIdx];
      }
      for (TInt i = 0; i < NodeAttrV.Len(); i++) {
        TStr ColName = NodeAttrV[i];
        TAttrType T = NodeTable->GetColType(ColName);
        TInt Index = NodeTable->GetColIdx(ColName);
        switch (T) {
          case atInt:
            Graph->AddIntAttrDatN(NId, NodeTable->IntCols[Index][CurrRowIdx], ColName);
            break;
          case atFlt:
            Graph->AddFltAttrDatN(NId, NodeTable->FltCols[Index][CurrRowIdx], ColName);
            break;
          case atStr:
            Graph->AddStrAttrDatN(NId, NodeTable->GetStrValIdx(Index, CurrRowIdx), ColName);
            break;
        }
      }
    }
  }
  // double endAdd = omp_get_wtime();
  // printf("Add time = %f\n", endAdd-endAlloc);

  return Graph;
}

template<class PGraphMP >

PGraphMP TSnap::ToNetworkMP2 ( PTable  Table, const TStr &  SrcCol, const TStr &  DstCol, TStrV &  SrcAttrV, TStrV &  DstAttrV, TStrV &  EdgeAttrV, TAttrAggr  AggrPolicy  )

inline

Implements table to network conversion in parallel. Not the recommended algorithm, using ToNetworkMP instead.

Definition at line 1118 of file conv.h.

                        {
  TStopwatch* Sw = TStopwatch::GetInstance();

  Sw->Start(TStopwatch::AllocateColumnCopies);
  const TInt SrcColIdx = Table->GetColIdx(SrcCol);
  const TInt DstColIdx = Table->GetColIdx(DstCol);
  const TInt NumRows = Table->NumValidRows;

  const TAttrType NodeType = Table->GetColType(SrcCol);
  Assert(NodeType == Table->GetColType(DstCol));



  TIntV SrcCol1, EdgeCol1, EdgeCol2, DstCol2;

  #pragma omp parallel sections num_threads(4)
  {
    #pragma omp section
    { SrcCol1.Reserve(NumRows, NumRows); }
    #pragma omp section
    { EdgeCol1.Reserve(NumRows, NumRows); }
    #pragma omp section
    { DstCol2.Reserve(NumRows, NumRows); }
    #pragma omp section
    { EdgeCol2.Reserve(NumRows, NumRows); }
  }
  Sw->Stop(TStopwatch::AllocateColumnCopies);
  Sw->Start(TStopwatch::CopyColumns);
  TIntPrV Partitions;
//  int NThreads = omp_get_max_threads();
  const int NThreads = 40;
  Table->GetPartitionRanges(Partitions, NThreads);
  TInt PartitionSize = Partitions[0].GetVal2()-Partitions[0].GetVal1()+1;

  // double endPartition = omp_get_wtime();
  // printf("Partition time = %f\n", endPartition-endResize);

  if (NodeType == atInt) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx();
        SrcCol1[RowId] = RowI.GetIntAttr(SrcColIdx);
        EdgeCol1[RowId] = RowId;
        DstCol2[RowId] = RowI.GetIntAttr(DstColIdx);
        EdgeCol2[RowId] = RowId;
        RowI++;
      }
    }
  }
  else if (NodeType == atStr) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx();
        SrcCol1[RowId] = RowI.GetStrMapById(SrcColIdx);
        EdgeCol1[RowId] = RowId;
        DstCol2[RowId] = RowI.GetStrMapById(DstColIdx);
        EdgeCol2[RowId] = RowId;
        RowI++;
      }
    }

  }

//  printf("NumRows = %d\n", NumRows.Val);
//  printf("NThreads = %d\n", NThreads);
//  for (int i = 0; i < Partitions.Len(); i++) {
//    printf("Partition %d %d->%d\n", i, Partitions[i].GetVal1().Val, Partitions[i].GetVal2().Val);
//  }
  int Parts[NThreads+1];
  for (int i = 0; i < NThreads; i++) {
    Parts[i] = NumRows.Val / NThreads * i;
  }
  Parts[NThreads] = NumRows;
//  for (int i = 0; i < NThreads+1; i++) {
//    printf("Parts[%d] = %d\n", i, Parts[i]);
//  }
  Sw->Stop(TStopwatch::CopyColumns);

  Sw->Start(TStopwatch::Sort);
  TInt ExtremePoints[4][NThreads];
  omp_set_num_threads(omp_get_max_threads());
  #pragma omp parallel
  {
    #pragma omp for schedule(static) nowait
    for (int i = 0; i < NThreads; i++) {
      TInt StartPos = Parts[i];
      TInt EndPos = Parts[i+1]-1;
      // TODO: Handle empty partition
      TTable::QSortKeyVal(SrcCol1, EdgeCol1, StartPos, EndPos);
      ExtremePoints[0][i] = SrcCol1[StartPos];
      ExtremePoints[2][i] = SrcCol1[EndPos];
    }
    #pragma omp for schedule(static) nowait
    for (int i = 0; i < NThreads; i++) {
      TInt StartPos = Parts[i];
      TInt EndPos = Parts[i+1]-1;
      // TODO: Handle empty partition
      TTable::QSortKeyVal(DstCol2, EdgeCol2, StartPos, EndPos);
      ExtremePoints[1][i] = DstCol2[StartPos];
      ExtremePoints[3][i] = DstCol2[EndPos];
    }
  }
//  for (int i = 0; i < NThreads; i++) {
//    printf("ExtremePoints[%d] = %d-%d -> %d-%d\n", i, ExtremePoints[0][i].Val, ExtremePoints[1][i].Val, ExtremePoints[2][i].Val, ExtremePoints[3][i].Val);
//  }

  // find min points
  TInt MinId(INT_MAX);
  for (int j = 0; j < 2; j++) {
    for (int i = 0; i < NThreads; i++) {
      if (MinId > ExtremePoints[j][i]) { MinId = ExtremePoints[j][i]; }
    }
  }
  TInt MaxId(-1);
  for (int j = 2; j < 4; j++) {
    for (int i = 0; i < NThreads; i++) {
      if (MaxId < ExtremePoints[j][i]) { MaxId = ExtremePoints[j][i]; }
    }
  }
//  printf("MinId = %d\n", MinId.Val);
//  printf("MaxId = %d\n", MaxId.Val);
  Sw->Stop(TStopwatch::Sort);

  Sw->Start(TStopwatch::Group);
//  const int NumCollectors = omp_get_max_threads();
  const int NumCollectors = 20;
  int Range = MaxId.Val - MinId.Val;
  TIntV IdRanges(NumCollectors+1);
  for (int j = 0; j < NumCollectors; j++) {
    IdRanges[j] = MinId + Range/NumCollectors*j;
  }
  IdRanges[NumCollectors] = MaxId+1;
//  for (int i = 0; i < NumCollectors+1; i++) {
//    printf("IdRanges[%d] = %d\n", i, IdRanges[i].Val);
//  }

  int SrcOffsets[NThreads][NumCollectors+1];
  #pragma omp parallel for schedule(static)
  for (int i = 0; i < NThreads; i++) {
    int CollectorId = 0;
    for (int j = Parts[i]; j < Parts[i+1]; j++) {
      while (SrcCol1[j] >= IdRanges[CollectorId]) {
        SrcOffsets[i][CollectorId++] = j;
      }
    }
    while (CollectorId <= NumCollectors) {
      SrcOffsets[i][CollectorId++] = Parts[i+1];
    }
  }
  int DstOffsets[NThreads][NumCollectors+1];
  #pragma omp parallel for schedule(static)
  for (int i = 0; i < NThreads; i++) {
    int CollectorId = 0;
    for (int j = Parts[i]; j < Parts[i+1]; j++) {
      while (DstCol2[j] >= IdRanges[CollectorId]) {
        DstOffsets[i][CollectorId++] = j;
      }
    }
    while (CollectorId <= NumCollectors) {
      DstOffsets[i][CollectorId++] = Parts[i+1];
    }
  }
//  for (int i = 0; i < NThreads; i++) {
//    for (int j = 0; j < NumCollectors+1; j++) {
//      printf("SrcOffsets[%d][%d] = %d\n", i, j, SrcOffsets[i][j]);
//    }
//  }
//  for (int i = 0; i < NThreads; i++) {
//    for (int j = 0; j < NumCollectors+1; j++) {
//      printf("DstOffsets[%d][%d] = %d\n", i, j, DstOffsets[i][j]);
//    }
//  }

  TIntV SrcCollectorOffsets(NumCollectors+1);
  SrcCollectorOffsets[0] = 0;
  for (int k = 0; k < NumCollectors; k++) {
    int SumOffset = 0;
    for (int i = 0; i < NThreads; i++) {
      SumOffset += SrcOffsets[i][k+1] - SrcOffsets[i][k];
    }
    SrcCollectorOffsets[k+1] = SrcCollectorOffsets[k] + SumOffset;
  }
  TIntV DstCollectorOffsets(NumCollectors+1);
  DstCollectorOffsets[0] = 0;
  for (int k = 0; k < NumCollectors; k++) {
    int SumOffset = 0;
    for (int i = 0; i < NThreads; i++) {
      SumOffset += DstOffsets[i][k+1] - DstOffsets[i][k];
    }
    DstCollectorOffsets[k+1] = DstCollectorOffsets[k] + SumOffset;
  }
//  for (int i = 0; i < NumCollectors+1; i++) {
//    printf("SrcCollectorOffsets[%d] = %d\n", i, SrcCollectorOffsets[i].Val);
//  }
//  for (int i = 0; i < NumCollectors+1; i++) {
//    printf("DstCollectorOffsets[%d] = %d\n", i, DstCollectorOffsets[i].Val);
//  }

  TIntV SrcCol3, EdgeCol3, EdgeCol4, DstCol4;
  #pragma omp parallel sections num_threads(4)
  {
    #pragma omp section
    { SrcCol3.Reserve(NumRows, NumRows); }
    #pragma omp section
    { EdgeCol3.Reserve(NumRows, NumRows); }
    #pragma omp section
    { DstCol4.Reserve(NumRows, NumRows); }
    #pragma omp section
    { EdgeCol4.Reserve(NumRows, NumRows); }
  }

  TIntV SrcNodeCounts(NumCollectors), DstNodeCounts(NumCollectors);
  #pragma omp parallel for schedule(static)
  for (int k = 0; k < NumCollectors; k++) {
    int ind = SrcCollectorOffsets[k];
    for (int i = 0; i < NThreads; i++) {
      for (int j = SrcOffsets[i][k]; j < SrcOffsets[i][k+1]; j++) {
        SrcCol3[ind] = SrcCol1[j];
        EdgeCol3[ind] = EdgeCol1[j];
        ind++;
      }
    }
    TTable::QSortKeyVal(SrcCol3, EdgeCol3, SrcCollectorOffsets[k], SrcCollectorOffsets[k+1]-1);
    int SrcCount = 0;
    if (SrcCollectorOffsets[k+1] > SrcCollectorOffsets[k]) {
      SrcCount = 1;
      for (int j = SrcCollectorOffsets[k]+1; j < SrcCollectorOffsets[k+1]; j++) {
        if (SrcCol3[j] != SrcCol3[j-1]) { SrcCount++; }
      }
    }
    SrcNodeCounts[k] = SrcCount;

    ind = DstCollectorOffsets[k];
    for (int i = 0; i < NThreads; i++) {
      for (int j = DstOffsets[i][k]; j < DstOffsets[i][k+1]; j++) {
        DstCol4[ind] = DstCol2[j];
        EdgeCol4[ind] = EdgeCol2[j];
        ind++;
      }
    }
    TTable::QSortKeyVal(DstCol4, EdgeCol4, DstCollectorOffsets[k], DstCollectorOffsets[k+1]-1);
    int DstCount = 0;
    if (DstCollectorOffsets[k+1] > DstCollectorOffsets[k]) {
      DstCount = 1;
      for (int j = DstCollectorOffsets[k]+1; j < DstCollectorOffsets[k+1]; j++) {
        if (DstCol4[j] != DstCol4[j-1]) { DstCount++; }
      }
    }
    DstNodeCounts[k] = DstCount;
  }

  TInt TotalSrcNodes = 0;
  TIntV SrcIdOffsets;
  for (int i = 0; i < NumCollectors; i++) {
    SrcIdOffsets.Add(TotalSrcNodes);
    TotalSrcNodes += SrcNodeCounts[i];
  }

//  printf("Sorted = %d - %d\n", SrcCol3.IsSorted(), DstCol4.IsSorted());
//  for (int i = 0; i < NumRows-1; i++) {
//    if (SrcCol3[i] > SrcCol3[i+1]) { printf("i=%d: %d %d\n", i, SrcCol3[i].Val, SrcCol3[i+1].Val); }
//  }
//  for (int i = 0; i < NumRows-1; i++) {
//    if (DstCol4[i] > DstCol4[i+1]) { printf("i=%d: %d %d\n", i, DstCol4[i].Val, DstCol4[i+1].Val); }
//  }

  TInt TotalDstNodes = 0;
  TIntV DstIdOffsets;
  for (int i = 0; i < NumCollectors; i++) {
    DstIdOffsets.Add(TotalDstNodes);
    TotalDstNodes += DstNodeCounts[i];
  }

  // find vector of (node_id, start_offset) where start_offset is the index of the first row with node_id
  TIntPrV SrcNodeIds, DstNodeIds;
  #pragma omp parallel sections
  {
    #pragma omp section
    { SrcNodeIds.Reserve(TotalSrcNodes, TotalSrcNodes); }
    #pragma omp section
    { DstNodeIds.Reserve(TotalDstNodes, TotalDstNodes); }
  }

  // Find the starting offset of each node (in both src and dst)
  #pragma omp parallel for schedule(dynamic)
  for (int t = 0; t < 2*NumCollectors; t++) {
    if (t < NumCollectors) {
      TInt i = t;
      if (SrcCollectorOffsets[i] < SrcCollectorOffsets[i+1]) {
        TInt CurrNode = SrcCol3[SrcCollectorOffsets[i]];
        TInt ThreadOffset = SrcIdOffsets[i];
        SrcNodeIds[ThreadOffset] = TIntPr(CurrNode, SrcCollectorOffsets[i]);
        TInt CurrCount = 1;
        for (TInt j = SrcCollectorOffsets[i]+1; j < SrcCollectorOffsets[i+1]; j++) {
          while (j < SrcCollectorOffsets[i+1] && SrcCol3[j] == CurrNode) { j++; }
          if (j < SrcCollectorOffsets[i+1]) {
            CurrNode = SrcCol3[j];
            SrcNodeIds[ThreadOffset+CurrCount] = TIntPr(CurrNode, j);
            CurrCount++;
          }
        }
      }
    } else {
      TInt i = t - NumCollectors;
      if (DstCollectorOffsets[i] < DstCollectorOffsets[i+1]) {
        TInt CurrNode = DstCol4[DstCollectorOffsets[i]];
        TInt ThreadOffset = DstIdOffsets[i];
        DstNodeIds[ThreadOffset] = TIntPr(CurrNode, DstCollectorOffsets[i]);
        TInt CurrCount = 1;
        for (TInt j = DstCollectorOffsets[i]+1; j < DstCollectorOffsets[i+1]; j++) {
          while (j < DstCollectorOffsets[i+1] && DstCol4[j] == CurrNode) { j++; }
          if (j < DstCollectorOffsets[i+1]) {
            CurrNode = DstCol4[j];
            DstNodeIds[ThreadOffset+CurrCount] = TIntPr(CurrNode, j);
            CurrCount++;
          }
        }
      }
    }
  }
  Sw->Stop(TStopwatch::Group);

  Sw->Start(TStopwatch::MergeNeighborhoods);
  // Find the combined neighborhood (both out-neighbors and in-neighbors) of each node
  TIntTrV Nodes;
  Nodes.Reserve(TotalSrcNodes+TotalDstNodes);

  TInt i = 0, j = 0;
  while (i < TotalSrcNodes && j < TotalDstNodes) {
    if (SrcNodeIds[i].Val1 == DstNodeIds[j].Val1) {
      Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, j));
      i++;
      j++;
    } else if (SrcNodeIds[i].Val1 < DstNodeIds[j].Val1) {
      Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, -1));
      i++;
    } else {
      Nodes.Add(TIntTr(DstNodeIds[j].Val1, -1, j));
      j++;
    }
  }
  for (; i < TotalSrcNodes; i++) { Nodes.Add(TIntTr(SrcNodeIds[i].Val1, i, -1)); }
  for (; j < TotalDstNodes; j++) { Nodes.Add(TIntTr(DstNodeIds[j].Val1, -1, j)); }
  Sw->Stop(TStopwatch::MergeNeighborhoods);

  Sw->Start(TStopwatch::AddNeighborhoods);
  TInt NumNodes = Nodes.Len();
  PGraphMP Graph = PGraphMP::TObj::New(NumNodes, NumRows);
//  NumThreads = omp_get_max_threads();
//  int Delta = (NumNodes+NumThreads-1)/NumThreads;

  TVec<TIntV> InVV(NumNodes);
  TVec<TIntV> OutVV(NumNodes);

//  omp_set_num_threads(NumThreads);
  #pragma omp parallel for schedule(static,100)
  for (int m = 0; m < NumNodes; m++) {
    //double startTr = omp_get_wtime();
    //TIntV OutV, InV;
    TInt n, i, j;
    Nodes[m].GetVal(n, i, j);
    if (i >= 0) {
      TInt Offset = SrcNodeIds[i].GetVal2();
      TInt Sz = EdgeCol3.Len()-Offset;
      if (i < SrcNodeIds.Len()-1) { Sz = SrcNodeIds[i+1].GetVal2()-Offset; }
      OutVV[m].Reserve(Sz);
      OutVV[m].CopyUniqueFrom(EdgeCol3, Offset, Sz);
    }
    if (j >= 0) {
      TInt Offset = DstNodeIds[j].GetVal2();
      TInt Sz = EdgeCol4.Len()-Offset;
      if (j < DstNodeIds.Len()-1) { Sz = DstNodeIds[j+1].GetVal2()-Offset; }
      InVV[m].Reserve(Sz);
      InVV[m].CopyUniqueFrom(EdgeCol4, Offset, Sz);
    }
    Graph->AddNodeWithEdges(n, InVV[m], OutVV[m]);
  }
  Graph->SetNodes(NumNodes);
  Sw->Stop(TStopwatch::AddNeighborhoods);

  Sw->Start(TStopwatch::AddEdges);
  omp_set_num_threads(omp_get_max_threads());
  if (NodeType == atInt) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx(); // EdgeId
        TInt SrcId = RowI.GetIntAttr(SrcColIdx);
        TInt DstId = RowI.GetIntAttr(DstColIdx);
        Graph->AddEdgeUnchecked(RowId, SrcId, DstId);
        RowI++;
      }
    }
  }
  else if (NodeType == atStr) {
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < Partitions.Len(); i++) {
      TRowIterator RowI(Partitions[i].GetVal1(), Table());
      TRowIterator EndI(Partitions[i].GetVal2(), Table());
      while (RowI < EndI) {
        TInt RowId = RowI.GetRowIdx(); // EdgeId
        TInt SrcId = RowI.GetStrMapById(SrcColIdx);
        TInt DstId = RowI.GetStrMapById(DstColIdx);
        Graph->AddEdgeUnchecked(RowId, SrcId, DstId);
        RowI++;
      }
    }
  }
  Graph->SetEdges(NumRows);
  Sw->Stop(TStopwatch::AddEdges);

  // double endAdd = omp_get_wtime();
  // printf("Add time = %f\n", endAdd-endAlloc);

  return Graph;
}

template<class PGraphMP >

PGraphMP TSnap::ToNetworkMP2	(	PTable	Table,
		const TStr &	SrcCol,
		const TStr &	DstCol,
		TAttrAggr	AggrPolicy
	)

Calls ToNetworkMP2 with an empty attribute vector. Convenience wrapper.

Definition at line 1547 of file conv.h.

{
  TStrV V;
  return ToNetworkMP2<PGraphMP>(Table, SrcCol, DstCol, V, V, V, AggrPolicy);
}

void TSnap::WriteEdgeSchemaToFile	(	FILE *	F,
		TStrV &	IntAttrENames,
		TStrV &	FltAttrENames,
		TStrV &	StrAttrENames
	)

Definition at line 221 of file gio.cpp.

                                                                                                      {
  fprintf(F, "%s\t%s\t%s", EDGES_START.CStr(), SRC_ID_NAME.CStr(), DST_ID_NAME.CStr());
  for(int i = 0; i < IntAttrENames.Len(); i++) {
    fprintf(F, "\t%s:%s", INT_TYPE_PREFIX.CStr(), IntAttrENames[i].CStr());
  }
  for(int i = 0; i < FltAttrENames.Len(); i++) {
    fprintf(F, "\t%s:%s", FLT_TYPE_PREFIX.CStr(), FltAttrENames[i].CStr());
  }
  for(int i = 0; i < StrAttrENames.Len(); i++) {
    fprintf(F, "\t%s:%s", STR_TYPE_PREFIX.CStr(), StrAttrENames[i].CStr());
  }
  fprintf(F, "\n");
}

void TSnap::WriteEdgesToFile	(	FILE *	F,
		const PNEANet &	Graph,
		TStrV &	IntAttrENames,
		TStrV &	FltAttrENames,
		TStrV &	StrAttrENames
	)

Definition at line 238 of file gio.cpp.

                                                                                                                       {
  for (TNEANet::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
    fprintf(F, "%d\t%d", EI.GetSrcNId(), EI.GetDstNId());
    for(int i = 0; i < IntAttrENames.Len(); i++) {
      if (Graph->IsIntAttrDeletedE(EI.GetId(), IntAttrENames[i])) {
        fprintf(F, "\t%s", NULL_VAL.CStr());
        continue;
      }
      int AttrIntVal = Graph->GetIntAttrDatE(EI.GetId(), IntAttrENames[i]);
      fprintf(F, "\t%d", AttrIntVal);
    }
    for(int i = 0; i < FltAttrENames.Len(); i++) {
      if (Graph->IsFltAttrDeletedE(EI.GetId(), FltAttrENames[i])) {
        fprintf(F, "\t%s", NULL_VAL.CStr());
        continue;
      }
      double AttrFltVal = Graph->GetFltAttrDatE(EI.GetId(), FltAttrENames[i]);
      fprintf(F, "\t%f", AttrFltVal);
    }
    for(int i = 0; i < StrAttrENames.Len(); i++) {
      if (Graph->IsStrAttrDeletedE(EI.GetId(), StrAttrENames[i])) {
        fprintf(F, "\t%s", NULL_VAL.CStr());
        continue;
      }
      char * AttrStrVal = Graph->GetStrAttrDatE(EI.GetId(), StrAttrENames[i]).CStr();
      fprintf(F, "\t%s", AttrStrVal);
    }
    fprintf(F, "\n");
  }
}

void TSnap::WriteNodeSchemaToFile	(	FILE *	F,
		TStrV &	IntAttrNNames,
		TStrV &	FltAttrNNames,
		TStrV &	StrAttrNNames
	)

Definition at line 171 of file gio.cpp.

                                                                                                      {
  fprintf(F, "%s\t%s", NODES_START.CStr(), NID_NAME.CStr());
  for(int i = 0; i < IntAttrNNames.Len(); i++) {
    fprintf(F, "\t%s:%s", INT_TYPE_PREFIX.CStr(), IntAttrNNames[i].CStr());
  }
  for(int i = 0; i < FltAttrNNames.Len(); i++) {
    fprintf(F, "\t%s:%s", FLT_TYPE_PREFIX.CStr(), FltAttrNNames[i].CStr());
  }
  for(int i = 0; i < StrAttrNNames.Len(); i++) {
    fprintf(F, "\t%s:%s", STR_TYPE_PREFIX.CStr(), StrAttrNNames[i].CStr());
  }
  fprintf(F, "\n");
}

void TSnap::WriteNodesToFile	(	FILE *	F,
		const PNEANet &	Graph,
		TStrV &	IntAttrNNames,
		TStrV &	FltAttrNNames,
		TStrV &	StrAttrNNames
	)

Definition at line 188 of file gio.cpp.

                                                                                                                       {
  for (TNEANet::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    fprintf(F, "%d", NI.GetId());
    for(int i = 0; i < IntAttrNNames.Len(); i++) {
      if (Graph->IsIntAttrDeletedN(NI.GetId(), IntAttrNNames[i])) {
        fprintf(F, "\t%s", NULL_VAL.CStr());
        continue;
      }
      int AttrIntVal = Graph->GetIntAttrDatN(NI.GetId(), IntAttrNNames[i]);
      fprintf(F, "\t%d", AttrIntVal);
    }
    for(int i = 0; i < FltAttrNNames.Len(); i++) {
      if (Graph->IsFltAttrDeletedN(NI.GetId(), FltAttrNNames[i])) {
        fprintf(F, "\t%s", NULL_VAL.CStr());
        continue;
      }
      double AttrFltVal = Graph->GetFltAttrDatN(NI.GetId(), FltAttrNNames[i]);
      fprintf(F, "\t%f", AttrFltVal);
    }
    for(int i = 0; i < StrAttrNNames.Len(); i++) {
      if (Graph->IsStrAttrDeletedN(NI.GetId(), StrAttrNNames[i])) {
        fprintf(F, "\t%s", NULL_VAL.CStr());
        continue;
      }
      char * AttrStrVal = Graph->GetStrAttrDatN(NI.GetId(), StrAttrNNames[i]).CStr();
      fprintf(F, "\t%s", AttrStrVal);
    }
    fprintf(F, "\n");
  }
}

Variable Documentation

const TStr TSnap::CapAttrName = "capacity"

Definition at line 4 of file flow.h.

const TStr TSnap::DST_ID_NAME = ("DstNId")

Definition at line 10 of file gio.h.

const TStr TSnap::EDGES_START = ("#EDGES")

Definition at line 6 of file gio.h.

const TStr TSnap::END_SENTINEL = ("#END")

Definition at line 8 of file gio.h.

const TStr TSnap::FLT_TYPE_PREFIX = ("Flt")

Definition at line 13 of file gio.h.

const TStr TSnap::INT_TYPE_PREFIX = ("Int")

Definition at line 12 of file gio.h.

const TStr TSnap::NID_NAME = ("NId")

Definition at line 11 of file gio.h.

const TStr TSnap::NODES_START = ("#NODES")

Definition at line 7 of file gio.h.

const TStr TSnap::NULL_VAL = ("__null__")

Definition at line 15 of file gio.h.

const TStr TSnap::SRC_ID_NAME = ("SrcNId")

Definition at line 9 of file gio.h.

const TStr TSnap::STR_TYPE_PREFIX = ("Str")

Definition at line 14 of file gio.h.