C

EigenvectorCentrality

Show Usages
Computes an eigenvector centrality for each node of a given undirected, unweighted graph.
Inheritance Hierarchy

Remarks

Eigenvector centrality is a measure of the influence a node has on a network: The more nodes point to a node the higher is that node's centrality.

The centrality values are scaled so that the largest centrality value is 1.0.

Other Centrality Measures

yFiles for HTML supports a number of other centrality measures:

Examples

const result = new EigenvectorCentrality().run(graph)

// add node labels for centrality values
// and adjust node size according to centrality
result.nodeCentrality.forEach(({ key, value }) => {
  const node = key
  const centrality = value
  graph.addLabel(node, String(centrality))
  graph.setNodeLayout(
    node,
    new Rect(node.layout.center, new Size(centrality, centrality)),
  )
})

See Also

Developer's Guide

API

eigenvectorCentrality

Members

No filters for this type

Constructors

EigenvectorCentrality

()

Parameters

Properties

precision

: number
Gets or sets the precision used during the calculation of the power iteration method, i.e., the maximum possible difference to consider two values as equal.
The default is 0.001.
final

subgraphEdges

: ItemCollection<IEdge>
Gets or sets the collection of edges which define a subset of the graph for the algorithms to work on.

If nothing is set, all edges of the graph will be processed.

If only the ItemCollection<TItem>.excludes are set, all edges in the graph except those provided in the ItemCollection<TItem>.excludes are processed.

Note that edges which start or end at nodes which are not in the subgraphNodes are automatically not considered by the algorithm.

ItemCollection<T> instances may be shared among algorithm instances and will be (re-)evaluated upon (re-)execution of the algorithm.

The edges provided here must be part of the graph which is passed to the run method.
conversionfinal

Examples

Calculating the eigenvector centrality on a subset of the graph
// configure the algorithm
const algorithm = new EigenvectorCentrality({
  // Ignore edges without target arrow heads
  subgraphEdges: {
    excludes: (edge: IEdge): boolean =>
      edge.style instanceof PolylineEdgeStyle &&
      edge.style.targetArrow instanceof Arrow &&
      edge.style.targetArrow.type === ArrowType.NONE,
  },
})
// run the algorithm
const result = algorithm.run(graph)
// add labels for centrality values
result.nodeCentrality.forEach(({ key, value }) =>
  graph.addLabel(key, String(value)),
)

subgraphNodes

: ItemCollection<INode>
Gets or sets the collection of nodes which define a subset of the graph for the algorithms to work on.

If nothing is set, all nodes of the graph will be processed.

If only the ItemCollection<TItem>.excludes are set, all nodes in the graph except those provided in the ItemCollection<TItem>.excludes are processed.

ItemCollection<T> instances may be shared among algorithm instances and will be (re-)evaluated upon (re-)execution of the algorithm.

The nodes provided here must be part of the graph which is passed to the run method.
conversionfinal

Examples

Calculating the eigenvector centrality on a subset of the graph
// configure the algorithm
const algorithm = new EigenvectorCentrality({
  subgraphNodes: {
    // only consider elliptical nodes in the graph
    includes: (node: INode): boolean =>
      node.style instanceof ShapeNodeStyle &&
      node.style.shape === ShapeNodeShape.ELLIPSE,
    // but ignore the first node, regardless of its shape
    excludes: graph.nodes.first()!,
  },
})
// run the algorithm
const result = algorithm.run(graph)
// add labels for centrality values
result.nodeCentrality.forEach(({ key, value }) =>
  graph.addLabel(key, String(value)),
)

Methods

run

(graph: IGraph): EigenvectorCentralityResult
Computes an eigenvector centrality for each node of a given undirected, unweighted graph.

Eigenvector centrality is a measure of the influence a node has on a network: The more nodes point to a node the higher is that node's centrality.

The centrality values are scaled so that the largest centrality value is 1.0.

The result obtained from this algorithm is a snapshot which is no longer valid once the graph has changed, e.g. by adding or removing nodes or edges.
final

Parameters

graph: IGraph
The input graph to run the algorithm on.

Return Value

EigenvectorCentralityResult
A EigenvectorCentralityResult from which the calculated centrality values can be obtained.

Throws

Exception ({ name: 'InvalidOperationError' })
If the algorithm can't create a valid result due to an invalid graph structure or wrongly configured properties.

Examples

const result = new EigenvectorCentrality().run(graph)

// add node labels for centrality values
// and adjust node size according to centrality
result.nodeCentrality.forEach(({ key, value }) => {
  const node = key
  const centrality = value
  graph.addLabel(node, String(centrality))
  graph.setNodeLayout(
    node,
    new Rect(node.layout.center, new Size(centrality, centrality)),
  )
})