Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## edu.uci.ics.jung.algorithms.metrics
Class StructuralHoles

    java.lang.Object
      edu.uci.ics.jung.algorithms.metrics.StructuralHoles

public class StructuralHoles
extends Object

Calculates some of the measures from Burt's text "Structural Holes: The Social Structure of Competition".

Notes:

Each of these measures assumes that each edge has an associated non-null weight whose value is accessed through the specified `NumberEdgeValue` instance.
Nonexistent edges are treated as edges with weight 0 for purposes of edge weight calculations.

Based on code donated by Jasper Voskuilen and Diederik van Liere of the Department of Information and Decision Sciences at Erasmus University.

Author:
  Joshua O'Madadhain, Jasper Voskuilen
See Also:
  "Ronald Burt, Structural Holes: The Social Structure of Competition"

Field Summary
`protected NumberEdgeValue` | `nev`

Constructor Summary
`StructuralHoles(NumberEdgeValue nev)` Creates a `StructuralHoles` instance based on the edge weights specified by `nev`.

Method Summary
`double` | `aggregateConstraint(Vertex v)` The aggregate constraint on `v`.
`double` | `constraint(Vertex v)` Burt's constraint measure (equation 2.4, page 55 of Burt, 1992).
`double` | `effectiveSize(Vertex v)` Burt's measure of the effective size of a vertex's network.
`double` | `efficiency(Vertex v)` Returns the effective size of `v` divided by the number of alters in `v`'s network.
`double` | `hierarchy(Vertex v)` Calculates the hierarchy value for a given vertex.
`double` | `localConstraint(Vertex v1, Vertex v2)` Returns the local constraint on `v` from a lack of primary holes around its neighbor `v2`.
`protected double` | `maxScaledMutualEdgeWeight(Vertex v1, Vertex v2)` The marginal strength of v1's relation with contact vertex2.
`protected double` | `mutualWeight(Vertex v1, Vertex v2)` Returns the weight of the edge from `v1` to `v2` plus the weight of the edge from `v2` to `v1`; if either edge does not exist, it is treated as an edge with weight 0.
`protected double` | `normalizedMutualEdgeWeight(Vertex v1, Vertex v2)` Returns the proportion of `v1`'s network time and energy invested in the relationship with `v2`.
`protected double` | `organizationalMeasure(Vertex v)` A measure of the organization of individuals within the subgraph centered on `v`.

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

Field Detail

### nev

    protected NumberEdgeValue nev

Constructor Detail

### StructuralHoles

    public StructuralHoles(NumberEdgeValue nev)

  Creates a `StructuralHoles` instance based on the edge weights specified by `nev`.

Method Detail

### effectiveSize

    public double effectiveSize(Vertex v)

  Burt's measure of the effective size of a vertex's network. Essentially, the number of neighbors minus the average degree of those in `v`'s neighbor set, not counting ties to `v`. Formally:

       effectiveSize(v) = v.degree() - (sum_{u in N(v)} sum_{w in N(u), w !=u,v} p(v,w)*m(u,w))

  where
  `N(a) = a.getNeighbors()`
  `p(v,w) =` normalized mutual edge weight of v and w
  `m(u,w)` = maximum-scaled mutual edge weight of u and w

  See Also:
    `normalizedMutualEdgeWeight(Vertex, Vertex)`, `maxScaledMutualEdgeWeight(Vertex, Vertex)`

### efficiency

    public double efficiency(Vertex v)

  Returns the effective size of `v` divided by the number of alters in `v`'s network. (In other words, `effectiveSize(v) / v.degree()`.) If `v.degree() == 0`, returns 0.

### constraint

    public double constraint(Vertex v)

  Burt's constraint measure (equation 2.4, page 55 of Burt, 1992). Essentially a measure of the extent to which `v` is invested in people who are invested in other of `v`'s alters (neighbors). The "constraint" is characterized by a lack of primary holes around each neighbor. Formally:

       constraint(v) = sum_{w in MP(v), w != v} localConstraint(v,w)

  where MP(v) is the subset of v's neighbors that are both predecessors and successors of v.

  See Also:
    `localConstraint(Vertex, Vertex)`

### hierarchy

    public double hierarchy(Vertex v)

  Calculates the hierarchy value for a given vertex. Returns `NaN` when `v`'s degree is 0, and 1 when `v`'s degree is 1. Formally:

       hierarchy(v) = (sum_{v in N(v), w != v} s(v,w) * log(s(v,w))}) / (v.degree() * Math.log(v.degree())

  where
  `N(v) = v.getNeighbors()`
  `s(v,w) = localConstraint(v,w) / (aggregateConstraint(v) / v.degree())`

  See Also:
    `localConstraint(Vertex, Vertex)`, `aggregateConstraint(Vertex)`

### localConstraint

    public double localConstraint(Vertex v1,
                                  Vertex v2)

  Returns the local constraint on `v` from a lack of primary holes around its neighbor `v2`. Based on Burt's equation 2.4. Formally:

       localConstraint(v1, v2) = ( p(v1,v2) + ( sum_{w in N(v)} p(v1,w) * p(w, v2) ) )^2

  where
  `N(v) = v.getNeighbors()`
  `p(v,w) =` normalized mutual edge weight of v and w

  See Also:
    `normalizedMutualEdgeWeight(Vertex, Vertex)`

### aggregateConstraint

    public double aggregateConstraint(Vertex v)

  The aggregate constraint on `v`. Based on Burt's equation 2.7. Formally:

       aggregateConstraint(v) = sum_{w in N(v)} localConstraint(v,w) * O(w)

  where
  `N(v) = v.getNeighbors()`
  `O(w) = organizationalMeasure(w)`

### organizationalMeasure

    protected double organizationalMeasure(Vertex v)

  A measure of the organization of individuals within the subgraph centered on `v`. Burt's text suggests that this is in some sense a measure of how "replaceable" `v` is by some other element of this subgraph. Should be a number in the closed interval [0,1].

  This implementation returns 1. Users may wish to override this method in order to define their own behavior.

### normalizedMutualEdgeWeight

    protected double normalizedMutualEdgeWeight(Vertex v1,
                                                Vertex v2)

  Returns the proportion of `v1`'s network time and energy invested in the relationship with `v2`. Formally:

       normalizedMutualEdgeWeight(a,b) = mutual_weight(a,b) / (sum_c mutual_weight(a,c))

  Returns 0 if either numerator or denominator = 0, or if `v1 == v2`.

  See Also:
    `mutualWeight(Vertex, Vertex)`

### mutualWeight

    protected double mutualWeight(Vertex v1,
                                  Vertex v2)

  Returns the weight of the edge from `v1` to `v2` plus the weight of the edge from `v2` to `v1`; if either edge does not exist, it is treated as an edge with weight 0. Undirected edges are treated as two antiparallel directed edges (that is, if there is one undirected edge with weight w connecting `v1` to `v2`, the value returned is 2w). Ignores parallel edges; if there are any such, one is chosen at random. Throws `NullPointerException` if either edge is present but not assigned a weight by the constructor-specified `NumberEdgeValue`.

### maxScaledMutualEdgeWeight

    protected double maxScaledMutualEdgeWeight(Vertex v1,
                                               Vertex v2)

  The marginal strength of v1's relation with contact vertex2. Formally:

       normalized_mutual_weight = mutual_weight(a,b) / (max_c mutual_weight(a,c))

  Returns 0 if either numerator or denominator is 0, or if `v1 == v2`.

  See Also:
    `mutualWeight(Vertex, Vertex)`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD