GraphMetrics (Cognitive Foundry)

java.lang.Object
- gov.sandia.cognition.graph.GraphMetrics<NodeNameType>

Type Parameters:

NodeNameType - The type for node names in the input graph
```
public class GraphMetrics<NodeNameType>
extends java.lang.Object
```
This class is intended to allow programmers to get any number of graph metrics for any input graph without bloating the intentionally spartan graph implementations and interfaces. This class computes all values of a given type when one of them is requested as the runtime costs for all is often quite similar to the runtime costs for one -- although at the cost of increased storage. However, if no instances of a metric are ever requested (e.g., no Jaccard similarities are requested), then they are never computed or stored (unless required as a prerequisite for some other requested metric). NOTE: If the graph is changed after any metric is computed, this has no way of knowing intrinsically. Thus, if you have altered the graph by adding a node or an edge, you need to call the clear method herein to remove old cached values.

Author:

jdwendt

Constructor Summary

Constructors
Constructor and Description

GraphMetrics(DirectedNodeEdgeGraph<NodeNameType> graph)
Initialize this as an empty metrics class surrounding the input graph.

Constructors
Constructor and Description
`GraphMetrics(DirectedNodeEdgeGraph<NodeNameType> graph)` Initialize this as an empty metrics class surrounding the input graph.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()` Clears all cached metrics for the originally input graph.
`int[]`	`computeAllDistancesForNode(int nodeId)` Helper which computes Dijkstra's Algorithm for the input node and returns all of the distances to all other nodes from this node.
`int`	`degree(int nodeId)` Return the degree for the input nodeId.
`int`	`degree(NodeNameType nodeName)` Return the degree for the input node.
`double`	`degreeAssortativity()` Returns the whole-graph degree assortativity score.
`int`	`getDiameter()` Returns the diameter for this graph.
`double`	`getEdgeJaccardSimilarity(int edgeId)` Returns the Jaccard Similarity for each edge of the graph.
`java.util.Set<java.lang.Integer>`	`getEdgeTriangleOtherEndpointIds(int edgeId)` Returns the ids for the third nodes for all triangles this edge participates in.
`java.util.Set<NodeNameType>`	`getEdgeTriangleOtherEndpointNames(int edgeId)` Returns the names for the third nodes for all triangles this edge participates in.
`java.util.Set<Pair<java.lang.Integer,java.lang.Integer>>`	`getNodeTriangleEndpointIds(int nodeId)` Returns the other two endpoint ids for all triangles the node participates in.
`java.util.Set<Pair<java.lang.Integer,java.lang.Integer>>`	`getNodeTriangleEndpointIds(NodeNameType nodeName)` Returns the other two endpoint ids for all triangles the node participates in.
`java.util.Set<Pair<NodeNameType,NodeNameType>>`	`getNodeTriangleEndpoints(int nodeId)` Returns the other two endpoint names for all triangles the node participates in.
`java.util.Set<Pair<NodeNameType,NodeNameType>>`	`getNodeTriangleEndpoints(NodeNameType nodeName)` Returns the other two endpoint names for all triangles the node participates in.
`double`	`getPerEdgeTriangleDensity(int edgeId)` Returns the per-edge triangle density for the input edge
`double`	`getPerNodeBetweennessCentrality(NodeNameType node)` Returns the per-node betweenness centrality for the input node
`double`	`getPerNodeBetweennessCentralityById(int nodeId)` Returns the per-node betweenness centrality for the input node
`int`	`getPerNodeEccentricity(NodeNameType node)` Returns the per-node eccentricity for the input node
`int`	`getPerNodeEccentricityById(int nodeId)` Returns the per-node eccentricity for the input node
`int`	`getRadius()` Returns the radius for this graph.
`void`	`initializeDegreeAssortativity()` Initialize the degree assortativity for the whole graph.
`void`	`initializeEdgeTriangles()` Initializes the datastructure for all triangles that all nodes and edges participate in.
`void`	`initializeNodeDegrees()` Initializes the unweighted degree values for all nodes in the graph.
`void`	`initializeNodeNeighbors()` Initializes the neighbors (undirected) for all nodes in the graph at once.
`void`	`initializeNodeSuccessors()` Initializes the node successors (directed version of neighbors).
`void`	`initializeNodeTriangles()` Initializes the datastructure for all triangles that all nodes and edges participate in.
`void`	`initializePerEdgeJaccardSimilarity()` Initializes the Jaccard similarity for each edge in the graph.
`void`	`initializePerEdgeTriangleDensity()` Initializes the per-edge triangle density.
`void`	`initializePerNodeBetweennessCentrality()` Initializes the per-node eccentricity.
`void`	`initializePerNodeEccentricity()` Initializes the per-node eccentricity.
`boolean`	`isWcc()` Returns true if the graph is a single weakly connected component (WCC), else false.
`java.util.Set<java.lang.Integer>`	`neighborIds(int nodeId)` Returns the ids of all neighbors for the input node id.
`java.util.Set<java.lang.Integer>`	`neighborIds(NodeNameType nodeName)` Returns the ids of all neighbors for the input node name.
`java.util.Set<NodeNameType>`	`neighbors(int nodeId)` Returns the names of all neighbors for the input node id.
`java.util.Set<NodeNameType>`	`neighbors(NodeNameType nodeName)` Returns the names of all neighbors for the input node name.
`int`	`numEdges()` Returns the number of edges in the graph.
`int`	`numEdgeTriangles(int edgeId)` Returns the number of triangles the input edge participates in.
`int`	`numNeighbors(int nodeId)` Returns the number of neighbors for the input node id.
`int`	`numNeighbors(NodeNameType nodeName)` Returns the number of neighbors for the input node name.
`int`	`numNodes()` Returns the number of nodes in the graph.
`int`	`numNodeTriangles(int nodeId)` Returns the number of triangles the node participates in.
`int`	`numNodeTriangles(NodeNameType nodeName)` Returns the number of triangles the node participates in.
`int`	`numSuccessors(int nodeId)` Returns the number of direct successors for the input node.
`int`	`numSuccessors(NodeNameType nodeName)` Returns the number of direct successors for the input node.
`java.util.Set<java.lang.Integer>`	`successorIds(int nodeId)` Returns the id for all direct successors for the input node.
`java.util.Set<java.lang.Integer>`	`successorIds(NodeNameType nodeName)` Returns the ids of the direct successors for the input node.
`java.util.Set<NodeNameType>`	`successors(int nodeId)` Returns the node names for all direct successors to the input node.
`java.util.Set<NodeNameType>`	`successors(NodeNameType nodeName)` Returs the node names for all direct successors to the input node.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - GraphMetrics
```
public GraphMetrics(DirectedNodeEdgeGraph<NodeNameType> graph)
```
    Initialize this as an empty metrics class surrounding the input graph. Note that if you alter the input graph after creating this class, you should call the clear method.
    
    Parameters:
    
    graph - The graph whose metrics will be computed and returned by this
- Method Detail
  - clear
```
public void clear()
```
    Clears all cached metrics for the originally input graph. This method created as it is possible that the graph is modified after being passed into the constructor of this class. If the graph is changed, this class has no way of knowing. This method resets all previously computed metrics.
  - numNodes
```
public int numNodes()
```
    Returns the number of nodes in the graph. (O(1) on all calls)
    
    Returns:
    
    the number of nodes in the graph
  - numEdges
```
public int numEdges()
```
    Returns the number of edges in the graph. (O(1) on all calls)
    
    Returns:
    
    the number of edges in the graph
  - initializeNodeDegrees
```
public void initializeNodeDegrees()
```
    Initializes the unweighted degree values for all nodes in the graph. Note that repeated edges count once for each repeat. Furthermore, self-loops increase the degree by 2. O(n + m)
  - degree
```
public int degree(int nodeId)
```
    Return the degree for the input nodeId. O(n+m) on first call to either degree method, O(1) on all further calls.
    
    Parameters:
    
    nodeId - The node id of the node whose degree is wanted
    
    Returns:
    
    the degree for the input nodeId
  - degree
```
public int degree(NodeNameType nodeName)
```
    Return the degree for the input node. O(n+m) on the first call to either degree method, O(1) on all further calls.
    
    Parameters:
    
    nodeName - The name of the node whose degree is wanted
    
    Returns:
    
    the degree for the input nodeName
  - initializeNodeNeighbors
```
public void initializeNodeNeighbors()
```
    Initializes the neighbors (undirected) for all nodes in the graph at once. O(n + m)
  - numNeighbors
```
public int numNeighbors(int nodeId)
```
    Returns the number of neighbors for the input node id. This is different from degree as repeated edges and self loops don't increase the count. O(n+m) for first neighbor method called, O(1) for all later.
    
    Parameters:
    
    nodeId - The node whose number of neighbors is wanted
    
    Returns:
    
    The number of neighbors for the input node
  - numNeighbors
```
public int numNeighbors(NodeNameType nodeName)
```
    Returns the number of neighbors for the input node name. This is different from degree as repeated edges and self loops don't increase the count. O(n+m) for the first neighbor method called, O(1) for all later.
    
    Parameters:
    
    nodeName - The node whose number of neighbors is wanted
    
    Returns:
    
    the number of neighbors for the input node
  - neighborIds
```
public java.util.Set<java.lang.Integer> neighborIds(int nodeId)
```
    Returns the ids of all neighbors for the input node id. Note that neighbors connected multiple times by repeated edges are included only once. O(n+m) for the first neighbor method called, O(1) for all later.
    
    Parameters:
    
    nodeId - The ndoe whose neighbor ids are wanted
    
    Returns:
    
    the ids of all neighbors.
  - neighborIds
```
public java.util.Set<java.lang.Integer> neighborIds(NodeNameType nodeName)
```
    Returns the ids of all neighbors for the input node name. Note that neighbors connected multiple times by repeated edges are included only once. O(n+m) for the first neighbor method called, O(1) for all later.
    
    Parameters:
    
    nodeName - The node whose neighbor ids are wanted
    
    Returns:
    
    the ids of all neighbors.
  - neighbors
```
public java.util.Set<NodeNameType> neighbors(int nodeId)
```
    Returns the names of all neighbors for the input node id. Note that neighbors connected multiple times by repeated edges are included only once. O(n+m) for the first neighbor method called, O(1) for all later.
    
    Parameters:
    
    nodeId - The node whose neighbor names are wanted
    
    Returns:
    
    the names of all neighbors
  - neighbors
```
public java.util.Set<NodeNameType> neighbors(NodeNameType nodeName)
```
    Returns the names of all neighbors for the input node name. Note that neighbors connected multiple times by repeated edges are included only once. O(n+m) for the first neighbor method called, O(1) for all later.
    
    Parameters:
    
    nodeName - The node whose neighbor names are wanted
    
    Returns:
    
    the names of all neighbors
  - initializeNodeSuccessors
```
public void initializeNodeSuccessors()
```
    Initializes the node successors (directed version of neighbors). O(n+m).
  - numSuccessors
```
public int numSuccessors(int nodeId)
```
    Returns the number of direct successors for the input node. This is different from degree in two ways: First, it doesn't count repeated edges. Second, it is directed; it counts nodes that can be reached by an edge originating at this node. O(m+n) for first successors method called, O(1) for later.
    
    Parameters:
    
    nodeId - The node whose successor count is desired
    
    Returns:
    
    the number of successors
  - numSuccessors
```
public int numSuccessors(NodeNameType nodeName)
```
    Returns the number of direct successors for the input node. This is different from degree in two ways: First, it doesn't count repeated edges. Second, it is directed; it counts nodes that can be reached by an edge originating at this node. O(m+n) for first successors method called, O(1) for later.
    
    Parameters:
    
    nodeName - The node whose successor count is desired
    
    Returns:
    
    the number of successors
  - successorIds
```
public java.util.Set<java.lang.Integer> successorIds(int nodeId)
```
    Returns the id for all direct successors for the input node. This is different from neighbors as it is directed; it returns nodes that can be reached by an edge originating at this node. O(m+n) for first successors method called, O(1) for later.
    
    Parameters:
    
    nodeId - The node whose successors' ids is desired
    
    Returns:
    
    the ids of successors for this node
  - successorIds
```
public java.util.Set<java.lang.Integer> successorIds(NodeNameType nodeName)
```
    Returns the ids of the direct successors for the input node. This is different from neighbors as it is directed; it returns nodes that can be reached by an edge originating at this node. O(m+n) for first successors method called, O(1) for later.
    
    Parameters:
    
    nodeName - The node whose successors' ids is desired
    
    Returns:
    
    the ids of successors for this node
  - successors
```
public java.util.Set<NodeNameType> successors(int nodeId)
```
    Returns the node names for all direct successors to the input node. This is different from neighbors as it is directed; it returns nodes that can be reached by an edge originating at this node. O(m+n) for first successors method called, O(1) for later.
    
    Parameters:
    
    nodeId - The node whose successors' names is desired
    
    Returns:
    
    the names of successors for this node
  - successors
```
public java.util.Set<NodeNameType> successors(NodeNameType nodeName)
```
    Returs the node names for all direct successors to the input node. This is different from neighbors as it is directed; it returns nodes that can be reached by an edge originating at this node. O(m+n) for first successors method called, O(1) for later.
    
    Parameters:
    
    nodeName - The node whose successors' names is desired
    
    Returns:
    
    the names of successors for this node
  - initializeNodeTriangles
```
@PublicationReference(author="Siddharth Suri and Sergei Vassilvitskii",
                      title="Counting Triangles and the Curse of the Last Reducer",
                      year=2011,
                      publication="Proceedings of the World Wide Web Conference (WWW)",
                      type=Conference)
public void initializeNodeTriangles()
```
    Initializes the datastructure for all triangles that all nodes and edges participate in. Note that this implementation uses the neighbors for each node, so does not allow triangles with only two nodes (where the third edge is a self-loop) nor does it create repeated triangles for nodes with repeated edges. According to the publication, this is O(m^(3/2)) in the worst case and O(m) at best.
  - numNodeTriangles
```
public int numNodeTriangles(int nodeId)
```
    Returns the number of triangles the node participates in. Note that this implementation does not permit triangles with only two nodes (where the third edge is a self-loop), nor does it count repeated triangles for nodes with repeated edges. O(m^(3/2)) for the first call to any triangle method, O(1) for later calls.
    
    Parameters:
    
    nodeId - The node whose number of triangles is desired
    
    Returns:
    
    The number of triangles which use this node
  - numNodeTriangles
```
public int numNodeTriangles(NodeNameType nodeName)
```
    Returns the number of triangles the node participates in. Note that this implementation does not permit triangles with only two nodes (where the third edge is a self-loop), nor does it count repeated triangles for nodes with repeated edges. O(m^(3/2)) for the first call to any triangle method, O(1) for later calls.
    
    Parameters:
    
    nodeName - The node whose number of triangles is desired
    
    Returns:
    
    The number of triangles which use this node
  - getNodeTriangleEndpointIds
```
public java.util.Set<Pair<java.lang.Integer,java.lang.Integer>> getNodeTriangleEndpointIds(int nodeId)
```
    Returns the other two endpoint ids for all triangles the node participates in. Note that this implementation does not permit triangles with only two nodes (where the third edge is a self-loop), nor does it count repeated triangles for nodes with repeated edges. O(m^(3/2)) for the first call to any triangle method, O(1) for later calls.
    
    Parameters:
    
    nodeId - The node whose triangles are requested
    
    Returns:
    
    The other two endpoint ids for all triangles which use this node
  - getNodeTriangleEndpointIds
```
public java.util.Set<Pair<java.lang.Integer,java.lang.Integer>> getNodeTriangleEndpointIds(NodeNameType nodeName)
```
    Returns the other two endpoint ids for all triangles the node participates in. Note that this implementation does not permit triangles with only two nodes (where the third edge is a self-loop), nor does it count repeated triangles for nodes with repeated edges. O(m^(3/2)) for the first call to any triangle method, O(1) for later calls.
    
    Parameters:
    
    nodeName - The node whose triangles are requested
    
    Returns:
    
    The other two endpoint ids for all triangles which use this node
  - getNodeTriangleEndpoints
```
public java.util.Set<Pair<NodeNameType,NodeNameType>> getNodeTriangleEndpoints(int nodeId)
```
    Returns the other two endpoint names for all triangles the node participates in. Note that this implementation does not permit triangles with only two nodes (where the third edge is a self-loop), nor does it count repeated triangles for nodes with repeated edges. O(m^(3/2)) for the first call to any triangle method, O(1) for later calls.
    
    Parameters:
    
    nodeId - The node whose triangles are requested
    
    Returns:
    
    The other two endpoint names for all triangles which use this node
  - getNodeTriangleEndpoints
```
public java.util.Set<Pair<NodeNameType,NodeNameType>> getNodeTriangleEndpoints(NodeNameType nodeName)
```
    Returns the other two endpoint names for all triangles the node participates in. Note that this implementation does not permit triangles with only two nodes (where the third edge is a self-loop), nor does it count repeated triangles for nodes with repeated edges. O(m^(3/2)) for the first call to any triangle method, O(1) for later calls.
    
    Parameters:
    
    nodeName - The node whose triangles are requested
    
    Returns:
    
    The other two endpoint names for all triangles which use this node
  - initializeDegreeAssortativity
```
@PublicationReference(author="M. E. J. Newman",
                      title="Assortative mixing in networks",
                      type=Journal,
                      year=2002,
                      publication="Physical Review Letters")
public void initializeDegreeAssortativity()
```
    Initialize the degree assortativity for the whole graph. O(m)
  - degreeAssortativity
```
public double degreeAssortativity()
```
    Returns the whole-graph degree assortativity score. O(m) the first time called; O(1) any repeats.
    
    Returns:
    
    the whole-graph degree assortativity
  - initializePerEdgeJaccardSimilarity
```
@PublicationReference(title="Jaccard index",
                      type=WebPage,
                      year=2015,
                      author="Wikipedia",
                      url="https://en.wikipedia.org/wiki/Jaccard_index")
public void initializePerEdgeJaccardSimilarity()
```
    Initializes the Jaccard similarity for each edge in the graph. O(n+m)
  - getEdgeJaccardSimilarity
```
public double getEdgeJaccardSimilarity(int edgeId)
```
    Returns the Jaccard Similarity for each edge of the graph.
    
    Parameters:
    
    edgeId - The [0..m) edge index
    
    Returns:
    
    The Jaccard Similarity for the neighbors of the endpoints of the edge.
  - initializeEdgeTriangles
```
public void initializeEdgeTriangles()
```
    Initializes the datastructure for all triangles that all nodes and edges participate in. Note that this implementation uses the neighbors for each node, so does not allow triangles with only two nodes (where the third edge is a self-loop) nor does it create repeated triangles for nodes with repeated edges. According to the publication, this is O(m^(3/2)) in the worst case and O(m) at best.
  - numEdgeTriangles
```
public int numEdgeTriangles(int edgeId)
```
    Returns the number of triangles the input edge participates in.
    
    Parameters:
    
    edgeId - The edge whose triangle count is wanted
    
    Returns:
    
    the number of triangles the input edge participates in
  - getEdgeTriangleOtherEndpointIds
```
public java.util.Set<java.lang.Integer> getEdgeTriangleOtherEndpointIds(int edgeId)
```
    Returns the ids for the third nodes for all triangles this edge participates in.
    
    Parameters:
    
    edgeId - The edge whose triangles' third nodes are requested
    
    Returns:
    
    the ids for the third nodes for all triangles this edge participates in
  - getEdgeTriangleOtherEndpointNames
```
public java.util.Set<NodeNameType> getEdgeTriangleOtherEndpointNames(int edgeId)
```
    Returns the names for the third nodes for all triangles this edge participates in.
    
    Parameters:
    
    edgeId - The edge whose triangles' third names are requested
    
    Returns:
    
    the names for the third nodes for all triangles this edge participates in
  - initializePerEdgeTriangleDensity
```
public void initializePerEdgeTriangleDensity()
```
    Initializes the per-edge triangle density. This measure is based on the degrees of the two endpoints of the edge. Intuitively, this looks at how many of the possible connections that come off the endpoints pair off into triangles. If edgeTriangles and nodeDegrees not already initialized, this initializes those. This method requires O(m), but may require O(m^3/2)/O(m) (edgeTriangles) or O(n+m) (degrees).
  - getPerEdgeTriangleDensity
```
public double getPerEdgeTriangleDensity(int edgeId)
```
    Returns the per-edge triangle density for the input edge
    
    Parameters:
    
    edgeId - The edge whose density is requested
    
    Returns:
    
    the per-edge triangle density for the input edge
  - initializePerNodeEccentricity
```
@PublicationReference(author="Frank W. Takes and Walter A. Kosters",
                      title="Computing the Eccentricity Distribution of Large Graphs",
                      type=Journal,
                      publication="Algorithms - Open Access Journal",
                      year=2013,
                      pages={100,118},
                      url="http://www.mdpi.com/1999-4893/6/1/100")
public void initializePerNodeEccentricity()
```
    Initializes the per-node eccentricity.
  - computeAllDistancesForNode
```
@PublicationReference(author="Wikipedia",
                      title="Dijkstra\'s algorithm",
                      type=WebPage,
                      url="https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm",
                      year=2016)
public int[] computeAllDistancesForNode(int nodeId)
```
    Helper which computes Dijkstra's Algorithm for the input node and returns all of the distances to all other nodes from this node. This node's value is returned as 0. This assumes an unweighted graph and each edge costs 1. If the graph is disconnected (so no path exists between at least one pair of nodes), this returns Integer.MAX_VALUE for any unreachable nodes.
    
    Parameters:
    
    nodeId - The node from which to start the search
    
    Returns:
    
    the distances to all other nodes
  - getPerNodeEccentricityById
```
public int getPerNodeEccentricityById(int nodeId)
```
    Returns the per-node eccentricity for the input node
    
    Parameters:
    
    nodeId - The node whose eccentricity is requested
    
    Returns:
    
    the per-node eccentricity for the input node
  - getPerNodeEccentricity
```
public int getPerNodeEccentricity(NodeNameType node)
```
    Returns the per-node eccentricity for the input node
    
    Parameters:
    
    node - The node whose eccentricity is requested
    
    Returns:
    
    the per-node eccentricity for the input node
  - getRadius
```
public int getRadius()
```
    Returns the radius for this graph. NOTE: If the graph is not a single weakly connected component (WCC), the radius is ill-defined (for which component do you want the radius?), so this returns Integer.MAX_VALUE
    
    Returns:
    
    the radius for the graph if it is WCC, else Integer.MAX_VALUE
  - getDiameter
```
public int getDiameter()
```
    Returns the diameter for this graph. NOTE: If the graph is not a single weakly connected component (WCC), the diameter is ill-defined (for which component do you want the diameter?), so this returns Integer.MAX_VALUE
    
    Returns:
    
    the diameter for the graph if it is WCC, else Integer.MAX_VALUE
  - isWcc
```
public boolean isWcc()
```
    Returns true if the graph is a single weakly connected component (WCC), else false.
    
    Returns:
    
    true if this is WCC
  - initializePerNodeBetweennessCentrality
```
@PublicationReference(author="Ulrik Brandes",
                      title="A Faster Algorithm for Betweenness Centrality",
                      type=Journal,
                      publication="Journal of Mathematical Sociology",
                      year=2001,
                      pages={163,177})
public void initializePerNodeBetweennessCentrality()
```
    Initializes the per-node eccentricity.
  - getPerNodeBetweennessCentralityById
```
public double getPerNodeBetweennessCentralityById(int nodeId)
```
    Returns the per-node betweenness centrality for the input node
    
    Parameters:
    
    nodeId - The node whose betweenness centrality is requested
    
    Returns:
    
    the per-node betweenness centrality for the input node
  - getPerNodeBetweennessCentrality
```
public double getPerNodeBetweennessCentrality(NodeNameType node)
```
    Returns the per-node betweenness centrality for the input node
    
    Parameters:
    
    node - The node whose betweenness centrality is requested
    
    Returns:
    
    the per-node betweenness centrality for the input node

Class GraphMetrics<NodeNameType>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

GraphMetrics

Method Detail

clear

numNodes

numEdges

initializeNodeDegrees

degree

degree

initializeNodeNeighbors

numNeighbors

numNeighbors

neighborIds

neighborIds

neighbors

neighbors

initializeNodeSuccessors

numSuccessors

numSuccessors

successorIds

successorIds

successors

successors

initializeNodeTriangles

numNodeTriangles

numNodeTriangles

getNodeTriangleEndpointIds

getNodeTriangleEndpointIds

getNodeTriangleEndpoints

getNodeTriangleEndpoints

initializeDegreeAssortativity

degreeAssortativity

initializePerEdgeJaccardSimilarity

getEdgeJaccardSimilarity

initializeEdgeTriangles

numEdgeTriangles

getEdgeTriangleOtherEndpointIds

getEdgeTriangleOtherEndpointNames

initializePerEdgeTriangleDensity

getPerEdgeTriangleDensity

initializePerNodeEccentricity

computeAllDistancesForNode

getPerNodeEccentricityById

getPerNodeEccentricity

getRadius

getDiameter

isWcc

initializePerNodeBetweennessCentrality

getPerNodeBetweennessCentralityById

getPerNodeBetweennessCentrality