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< TNEANet >
struct	IsDirected< TNEGraph >
struct	IsDirected< TNGraph >
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< TNEANet >
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)<. More...
template<class PGraph >
int	CntUniqDirEdges (const PGraph &Graph)
	Counts unique directed edges in the graph Graph. Nodes (u,v)<. More...
template<class PGraph >
int	CntUniqBiDirEdges (const PGraph &Graph)
	Counts unique bidirectional edges in the graph Graph. Edge is bidirectional is there exist directed edges in both directions: (u,v) and (v,u) More...
template<class PGraph >
int	CntSelfEdges (const PGraph &Graph)
	Counts the number fo 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). GetBfsEffDiam3. 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. GetBfsEffDiam4. More...
double	GetDegreeCentr (const PUNGraph &Graph, const int &NId)
double	GetFarnessCentr (const PUNGraph &Graph, const int &NId)
double	GetClosenessCentr (const PUNGraph &Graph, const int &NId)
void	GetBetweennessCentr (const PUNGraph &Graph, const TIntV &BtwNIdV, TIntFltH &NodeBtwH, const bool &DoNodeCent, TIntPrFltH &EdgeBtwH, const bool &DoEdgeCent)
void	GetBetweennessCentr (const PUNGraph &Graph, TIntFltH &NodeBtwH, const double &NodeFrac)
void	GetBetweennessCentr (const PUNGraph &Graph, TIntPrFltH &EdgeBtwH, const double &NodeFrac)
void	GetBetweennessCentr (const PUNGraph &Graph, TIntFltH &NodeBtwH, TIntPrFltH &EdgeBtwH, const double &NodeFrac)
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...
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)
template<class PGraph >
int	GetNodeEcc (const PGraph &Graph, const int &NId, const bool &IsDir=false)
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	GetHits (const PGraph &Graph, TIntFltH &NIdHubH, TIntFltH &NIdAuthH, const int &MaxIter=20)
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	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...
const TStr	CapAttrName ("capacity")
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, TVec< TFltV > &LeftSV, TVec< TFltV > &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, TVec< TFltV > &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	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 &ArndEdges)
	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 &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. More...
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	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 >
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 &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 >
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	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<>
int	GetCmnNbrs< PUNGraph > (const PUNGraph &Graph, const int &NId1, const int &NId2, TIntV &NbrV)

Variables
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.

Function Documentation

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 281 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 262 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);
  }

const TStr TSnap::CapAttrName

(

"capacity"

)

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

Definition at line 488 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 439 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 723 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 825 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 fo 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 is 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 <code>u!=v</code>) are connected via an directted edge if there exists a directed edge from node \c u to node \c 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 <code>u!=v</code>) are connected via an undirected edge if there exists an edge in either direction <code>(u,v)</code> or <code>(v,u)</code>. 

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 1447 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.

                                                              {
  TIntH OutDegH;
  const int NEdges = Graph->GetEdges();
  for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
    OutDegH.AddDat(NI.GetId(), NI.GetOutDeg());
  }
  double BestQ = -1; // modularity
  TCnComV CurCmtyV;
  CmtyV.Clr();
  TIntV Cmty1, Cmty2;
  while (true) {
    TSnapDetail::CmtyGirvanNewmanStep(Graph, Cmty1, Cmty2);
    const double Q = TSnapDetail::_GirvanNewmanGetModularity(Graph, 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 403 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 288 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 398 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 520 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 549 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;
}

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 119 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 335 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 453 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. 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 58 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(TInt::Rnd, 0.5));
    const int NId2 = DegH.GetKey(DegH.GetRndKeyId(TInt::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 442 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 361 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 310 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[TInt::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 165 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 216 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.Val1), NewE2(E1.Val2, E2.Val2);
    if (NewE1.Val1!=NewE2.Val1 && NewE1.Val2!=NewE2.Val1 && NewE1.Val2!=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 263 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 478 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 547 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 {
    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 412 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 205 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 211 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 217 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 225 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);
}

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

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 28 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);
  TIntH sigma(nodes), d(nodes);
  // init
  for (TUNGraph::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 (NI.GetId() < NI.GetOutNId(e)) {
          EdgeBtwH.AddDat(TIntPr(NI.GetId(), NI.GetOutNId(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 TUNGraph::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 TUNGraph::TNodeI NI2 = Graph->GetNI(v);
      S.Push(v);
      const int VDat = d.GetDat(v);
      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);
        }
      }
    }
    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) {
          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::GetBetweennessCentr	(	const PUNGraph &	Graph,
		TIntFltH &	NIdBtwH,
		const double &	NodeFrac = 1.0
	)

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 103 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(); }
  }
  GetBetweennessCentr(Graph, NIdV, NodeBtwH, true, EdgeBtwH, false);
}

void TSnap::GetBetweennessCentr	(	const PUNGraph &	Graph,
		TIntPrFltH &	EdgeBtwH,
		const double &	NodeFrac = 1.0
	)

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 114 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(); }
  }
  GetBetweennessCentr(Graph, NIdV, NodeBtwH, false, EdgeBtwH, true);
}

void TSnap::GetBetweennessCentr	(	const PUNGraph &	Graph,
		TIntFltH &	NIdBtwH,
		TIntPrFltH &	EdgeBtwH,
		const double &	NodeFrac = 1.0
	)

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 125 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(); }
  }
  GetBetweennessCentr(Graph, NIdV, NodeBtwH, true, EdgeBtwH, true);
}

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 278 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 286 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). GetBfsEffDiam3.

Definition at line 293 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. GetBfsEffDiam4.

Definition at line 321 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 >

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 270 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 186 of file bfsdfs.h.

                                                                                                          {
  TBreathFS<PGraph> BFS(Graph, false);
  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();
}

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

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

Definition at line 22 of file centr.cpp.

                                                                {
  const double Farness = GetFarnessCentr(Graph, NId);
  if (Farness != 0.0) { return 1.0/Farness; }
  else { 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 100 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 114 of file triad.h.

                                                                                                    {
  TIntTrV NIdCOTriadV;
  GetTriads(Graph, NIdCOTriadV, SampleNodes);
  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 &	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.

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 137 of file triad.h.

                                                                                                                    {
  TIntTrV NIdCOTriadV;
  GetTriads(Graph, NIdCOTriadV, SampleNodes);
  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 >

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 383 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 390 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 413 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();
}

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 248 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 268 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)) {
        OutEdges++;
      }
    }
  }
  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 135 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,
		TVec< TFltV > &	EigVecV
	)

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

Definition at line 346 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 206 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 227 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;
    const typename PGraph::TObj::TEdgeI EI = Graph->GetEI(SrcNId, DstNId);
    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;
}

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

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 11 of file centr.cpp.

                                                              {
  TIntH NDistH(Graph->GetNodes());
  TSnap::GetShortPath<PUNGraph>(Graph, NId, NDistH, true, TInt::Mx);
  double sum = 0;
  for (TIntH::TIter I = NDistH.BegI(); I < NDistH.EndI(); I++) {
    sum += I->Dat();
  }
  if (NDistH.Len() > 1) { return sum/double(NDistH.Len()-1); }
  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();
}

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 293 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 183 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 209 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 196 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 229 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 139 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::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();
}

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 377 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 436 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 444 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();
}

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 168 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.

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 176 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 81 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 229 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 241 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 295 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 302 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 335 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 >

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

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 103 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 >

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 452 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 441 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 >

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::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 263 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 254 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,
		TVec< TFltV > &	LeftSV,
		TVec< TFltV > &	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 200 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 >

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 217 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 259 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 372 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 188 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 212 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::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 194 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 >

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::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::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 337 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 417 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 577 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 590 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 614 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 643 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 168 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 192 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;
}

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 104 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 125 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 in stored in StrToNIdH. To map between node names and ids use: NId = StrToNIdH.GetKeyId(NodeName) and TStr NodeName = StrToNIdH.GetKey(NId);

Definition at line 148 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;
}

TIntH TSnap::LoadNodeList

(

TStr

InFNmNodes

)

Definition at line 664 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 209 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() >= 3 && 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);
  }
}

TIntH TSnap::MaxCPGreedyBetter	(	const PUNGraph &	Graph,
		const int	k
	)

Returns centrality Maximum k group.

Definition at line 299 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 347 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 392 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 446 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;
}

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 84 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 982 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 842 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 >

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 243 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 385 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 423 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 367 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 258 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 283 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 310 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 339 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 241 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::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::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.