Network (networkanalysis 1.3.0 API)

java.lang.Object
- nl.cwts.networkanalysis.Network

All Implemented Interfaces:

java.io.Serializable
```
public class Network
extends java.lang.Object
implements java.io.Serializable
```
Network.
Weighted nodes and weighted edges are supported. Directed edges are not supported.

Network objects are immutable.

The adjacency matrix of the network is stored in a sparse compressed format.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`Network.RangeIterable` Iterable starting from a certain element to a certain element.
`class`	`Network.RangeIterator` Iterator capable of iterating over a specified range.

Field Summary

Fields
Modifier and Type	Field and Description
`protected LargeDoubleArray`	`edgeWeights` Edge weights.
`protected long[]`	`firstNeighborIndices` Index of the first neighbor of each node in the (@code neighbors} array.
`protected long`	`nEdges` Number of edges.
`protected LargeIntArray`	`neighbors` Neighbors of each node.
`protected int`	`nNodes` Number of nodes.
`protected double[]`	`nodeWeights` Node weights.
`protected double`	`totalEdgeWeightSelfLinks` Total edge weight of self links.

Constructor Summary

Constructors
Constructor and Description
`Network(double[] nodeWeights, LargeIntArray[] edges, boolean sortedEdges, boolean checkIntegrity)` Constructs a network based on a list of edges.
`Network(double[] nodeWeights, LargeIntArray[] edges, LargeDoubleArray edgeWeights, boolean sortedEdges, boolean checkIntegrity)` Constructs a network based on a list of edges.
`Network(double[] nodeWeights, long[] firstNeighborIndices, LargeIntArray neighbors, boolean checkIntegrity)` Constructs a network based on a list of neighbors.
`Network(double[] nodeWeights, long[] firstNeighborIndices, LargeIntArray neighbors, LargeDoubleArray edgeWeights, boolean checkIntegrity)` Constructs a network based on a list of neighbors.
`Network(int nNodes, boolean setNodeWeightsToTotalEdgeWeights, LargeIntArray[] edges, boolean sortedEdges, boolean checkIntegrity)` Constructs a network based on a list of edges.
`Network(int nNodes, boolean setNodeWeightsToTotalEdgeWeights, LargeIntArray[] edges, LargeDoubleArray edgeWeights, boolean sortedEdges, boolean checkIntegrity)` Constructs a network based on a list of edges.
`Network(int nNodes, boolean setNodeWeightsToTotalEdgeWeights, long[] firstNeighborIndices, LargeIntArray neighbors, boolean checkIntegrity)` Constructs a network based on a list of neighbors.
`Network(int nNodes, boolean setNodeWeightsToTotalEdgeWeights, long[] firstNeighborIndices, LargeIntArray neighbors, LargeDoubleArray edgeWeights, boolean checkIntegrity)` Constructs a network based on a list of neighbors.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`checkIntegrity()` Checks the integrity of the network.
`Network`	`createNetworkWithoutEdgeWeights()` Creates a copy of the network, but without edge weights.
`Network`	`createNetworkWithoutNodeAndEdgeWeights()` Creates a copy of the network, but without node and edge weights.
`Network`	`createNetworkWithoutNodeWeights()` Creates a copy of the network, but without node weights.
`Network`	`createNormalizedNetworkUsingAssociationStrength()` Creates a copy of the network in which the edge weights have been normalized using the association strength.
`Network`	`createNormalizedNetworkUsingFractionalization()` Creates a copy of the network in which the edge weights have been normalized using fractionalization.
`Network`	`createPrunedNetwork(int maxNEdges)` Creates a copy of the network that has been pruned in order to have a specified maximum number of edges.
`Network`	`createPrunedNetwork(long maxNEdges, java.util.Random random)` Creates a copy of the network that has been pruned in order to have a specified maximum number of edges.
`Network`	`createReducedNetwork(Clustering clustering)` Creates a reduced (or aggregate) network based on a clustering.
`Network`	`createSubnetwork(boolean[] nodesInSubnetwork)` Creates an induced subnetwork for specified nodes.
`Network`	`createSubnetwork(Clustering clustering, int cluster)` Creates an induced subnetwork for a specified cluster in a clustering.
`Network`	`createSubnetwork(int[] nodes)` Creates an induced subnetwork for specified nodes.
`Network`	`createSubnetworkLargestComponent()` Creates an induced subnetwork of the largest connected component.
`Network[]`	`createSubnetworks(Clustering clustering)` Creates induced subnetworks for the clusters in a clustering.
`LargeDoubleArray.FromToIterable`	`edgeWeights(int node)` Returns an iterable over all the edge weights of all incident edges of a node.
`LargeIntArray[]`	`getEdges()` Returns the list of edges.
`LargeDoubleArray`	`getEdgeWeights()` Returns the edge weights.
`double[]`	`getEdgeWeights(int node)` Returns the list of edge weights of a node.
`double[][]`	`getEdgeWeightsPerNode()` Returns a list of edge weights per node.
`long`	`getNEdges()` Returns the number of edges.
`int[]`	`getNeighbors(int node)` Returns the list of neighbors of a node.
`int[][]`	`getNeighborsPerNode()` Returns a list of neighbors per node.
`int`	`getNNeighbors(int node)` Returns the number of neighbors of a node.
`int[]`	`getNNeighborsPerNode()` Returns the number of neighbors per node.
`int`	`getNNodes()` Returns the number of nodes.
`double`	`getNodeWeight(int node)` Returns the weight of a node.
`double[]`	`getNodeWeights()` Returns the weight of each node.
`double`	`getTotalEdgeWeight()` Returns the total edge weight.
`double`	`getTotalEdgeWeight(int node)` Returns the total edge weight of a node.
`double[]`	`getTotalEdgeWeightPerNode()` Returns the total edge weight per node.
`double`	`getTotalEdgeWeightSelfLinks()` Returns the total edge weight of self links.
`double`	`getTotalNodeWeight()` Returns the total node weight.
`Clustering`	`identifyComponents()` Identifies the connected components of the network.
`Network.RangeIterable`	`incidentEdges(int node)` Returns an iterable over all the incident edges of a node.
`static Network`	`load(java.lang.String filename)` Loads a network from a file.
`LargeIntArray.FromToIterable`	`neighbors(int node)` Returns an iterable over all the neighbors of a node.
`void`	`save(java.lang.String filename)` Saves the network in a file.
`static void`	`sortEdges(LargeIntArray[] edges, LargeDoubleArray edgeWeights)` Sorts a list of edges and the corresponding edge weights.

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

- Field Detail
  - nNodes
```
protected int nNodes
```
    Number of nodes.
  - nEdges
```
protected long nEdges
```
    Number of edges.
    Each edge is counted twice, once in each direction.
  - nodeWeights
```
protected double[] nodeWeights
```
    Node weights.
  - firstNeighborIndices
```
protected long[] firstNeighborIndices
```
    Index of the first neighbor of each node in the (@code neighbors} array.
    The neighbors of node i are given by neighbors[firstNeighborIndices[i]], ..., neighbors[firstNeighborIndices[i + 1] - 1].
  - neighbors
```
protected LargeIntArray neighbors
```
    Neighbors of each node.
  - edgeWeights
```
protected LargeDoubleArray edgeWeights
```
    Edge weights.
  - totalEdgeWeightSelfLinks
```
protected double totalEdgeWeightSelfLinks
```
    Total edge weight of self links.
- Constructor Detail
  - Network
```
public Network(double[] nodeWeights,
               LargeIntArray[] edges,
               boolean sortedEdges,
               boolean checkIntegrity)
```
    Constructs a network based on a list of edges.
    The list of edges is provided in the two-dimensional array edges. Edge i connects nodes edges[0].get(i) and edges[1].get(i). Edges do not have weights. If sortedEdges is false, the list of edges does not need to be sorted and each edge must be included only once. If sortedEdgesis true, the list of edges must be sorted and each edge must be included twice, once in each direction.
    
    Parameters:
    
    nodeWeights - Node weights
    
    edges - Edge list
    
    sortedEdges - Indicates whether the edge list is sorted
    
    checkIntegrity - Indicates whether to check the integrity of the network
  - Network
```
public Network(double[] nodeWeights,
               LargeIntArray[] edges,
               LargeDoubleArray edgeWeights,
               boolean sortedEdges,
               boolean checkIntegrity)
```
    Constructs a network based on a list of edges.
    The list of edges is provided in the two-dimensional array edges. Edge i connects nodes edges[0].get(i) and edges[1].get(i) and has weight edgeWeights.get(i). If sortedEdges is false, the list of edges does not need to be sorted and each edge must be included only once. If sortedEdges is true, the list of edges must be sorted and each edge must be included twice, once in each direction.
    
    Parameters:
    
    nodeWeights - Node weights
    
    edges - Edge list
    
    edgeWeights - Edge weights
    
    sortedEdges - Indicates whether the edge list is sorted
    
    checkIntegrity - Indicates whether to check the integrity of the network
  - Network
```
public Network(double[] nodeWeights,
               long[] firstNeighborIndices,
               LargeIntArray neighbors,
               boolean checkIntegrity)
```
    Constructs a network based on a list of neighbors.
    The list of neighbors is provided in the array neighbors. The neighbors of node i are given by neighbors[firstNeighborIndices[i]], ..., neighbors[firstNeighborIndices[i + 1] - 1]. The array firstNeighborIndices must have a length of the number of nodes plus 1. The neighbors of a node must be listed in increasing order in the array neighbors. Edges do not have weights.
    
    Parameters:
    
    nodeWeights - Node weights
    
    firstNeighborIndices - Index of the first neighbor of each node
    
    neighbors - Neighbor list
    
    checkIntegrity - Indicates whether to check the integrity of the network
  - Network
```
public Network(double[] nodeWeights,
               long[] firstNeighborIndices,
               LargeIntArray neighbors,
               LargeDoubleArray edgeWeights,
               boolean checkIntegrity)
```
    Constructs a network based on a list of neighbors.
    The list of neighbors is provided in the array neighbors. The neighbors of node i are given by neighbors[firstNeighborIndices[i]], ..., neighbors[firstNeighborIndices[i + 1] - 1]. The array firstNeighborIndices must have a length of the number of nodes plus 1. The neighbors of a node must be listed in increasing order in the array neighbors. For each neighbor in the array neighbors, the corresponding edge weight is provided in the array edgeWeights.
    
    Parameters:
    
    nodeWeights - Node weights
    
    firstNeighborIndices - Index of the first neighbor of each node
    
    neighbors - Neighbor list
    
    edgeWeights - Edge weights
    
    checkIntegrity - Indicates whether to check the integrity of the network
  - Network
```
public Network(int nNodes,
               boolean setNodeWeightsToTotalEdgeWeights,
               LargeIntArray[] edges,
               boolean sortedEdges,
               boolean checkIntegrity)
```
    Constructs a network based on a list of edges.
    The list of edges is provided in the two-dimensional array edges. Edge i connects nodes edges[0].get(i) and edges[1].get(i). Edges do not have weights. If sortedEdges is false, the list of edges does not need to be sorted and each edge must be included only once. If sortedEdgesis true, the list of edges must be sorted and each edge must be included twice, once in each direction.
    
    If setNodeWeightsToTotalEdgeWeights is false, the weights of the nodes are set to 1. If setNodeWeightsToTotalEdgeWeights is true, the weight of a node is set equal to the total weight of the edges between the node and its neighbors.
    
    Parameters:
    
    nNodes - Number of nodes
    
    setNodeWeightsToTotalEdgeWeights - Indicates whether to set node weights equal to total edge weights
    
    edges - Edge list
    
    sortedEdges - Indicates whether the edge list is sorted
    
    checkIntegrity - Indicates whether to check the integrity of the network
  - Network
```
public Network(int nNodes,
               boolean setNodeWeightsToTotalEdgeWeights,
               LargeIntArray[] edges,
               LargeDoubleArray edgeWeights,
               boolean sortedEdges,
               boolean checkIntegrity)
```
    Constructs a network based on a list of edges.
    The list of edges is provided in the two-dimensional array edges. Edge i connects nodes edges[0].get(i) and edges[1].get(i) and has weight edgeWeights.get(i). If sortedEdges is false, the list of edges does not need to be sorted and each edge must be included only once. If sortedEdges is true, the list of edges must be sorted and each edge must be included twice, once in each direction.
    
    If setNodeWeightsToTotalEdgeWeights is false, the weights of the nodes are set to 1. If setNodeWeightsToTotalEdgeWeights is true, the weight of a node is set equal to the total weight of the edges between the node and its neighbors.
    
    Parameters:
    
    nNodes - Number of nodes
    
    setNodeWeightsToTotalEdgeWeights - Indicates whether to set node weights equal to total edge weights
    
    edges - Edge list
    
    edgeWeights - Edge weights
    
    sortedEdges - Indicates whether the edge list is sorted
    
    checkIntegrity - Indicates whether to check the integrity of the network
  - Network
```
public Network(int nNodes,
               boolean setNodeWeightsToTotalEdgeWeights,
               long[] firstNeighborIndices,
               LargeIntArray neighbors,
               boolean checkIntegrity)
```
    Constructs a network based on a list of neighbors.
    The list of neighbors is provided in the array neighbors. The neighbors of node i are given by neighbors[firstNeighborIndices[i]], ..., neighbors[firstNeighborIndices[i + 1] - 1]. The array firstNeighborIndices must have a length of the number of nodes plus 1. The neighbors of a node must be listed in increasing order in the array neighbors. Edges do not have weights.
    
    If setNodeWeightsToTotalEdgeWeights is false, the weights of the nodes are set to 1. If setNodeWeightsToTotalEdgeWeights is true, the weight of a node is set equal to the total weight of the edges between the node and its neighbors.
    
    Parameters:
    
    nNodes - Number of nodes
    
    setNodeWeightsToTotalEdgeWeights - Indicates whether to set node weights equal to total edge weights
    
    firstNeighborIndices - Index of the first neighbor of each node
    
    neighbors - Neighbor list
    
    checkIntegrity - Indicates whether to check the integrity of the network
  - Network
```
public Network(int nNodes,
               boolean setNodeWeightsToTotalEdgeWeights,
               long[] firstNeighborIndices,
               LargeIntArray neighbors,
               LargeDoubleArray edgeWeights,
               boolean checkIntegrity)
```
    Constructs a network based on a list of neighbors.
    The list of neighbors is provided in the array neighbors. The neighbors of node i are given by neighbors[firstNeighborIndices[i]], ..., neighbors[firstNeighborIndices[i + 1] - 1]. The array firstNeighborIndices must have a length of the number of nodes plus 1. The neighbors of a node must be listed in increasing order in the array neighbors. For each neighbor in the array neighbors, the corresponding edge weight is provided in the array edgeWeights.
    
    If setNodeWeightsToTotalEdgeWeights is false, the weights of the nodes are set to 1. If setNodeWeightsToTotalEdgeWeights is true, the weight of a node is set equal to the total weight of the edges between the node and its neighbors.
    
    Parameters:
    
    nNodes - Number of nodes
    
    setNodeWeightsToTotalEdgeWeights - Indicates whether to set node weights equal to total edge weights
    
    firstNeighborIndices - Index of the first neighbor of each node
    
    neighbors - Neighbor list
    
    edgeWeights - Edge weights
    
    checkIntegrity - Indicates whether to check the integrity of the network
- Method Detail
  - load
```
public static Network load(java.lang.String filename)
                    throws java.lang.ClassNotFoundException,
                           java.io.IOException
```
    Loads a network from a file.
    
    Parameters:
    
    filename - File from which a network is loaded
    
    Returns:
    
    Loaded network
    
    Throws:
    
    java.lang.ClassNotFoundException - Class not found
    
    java.io.IOException - Could not read the file
    
    See Also:
    
    save(String filename)
  - save
```
public void save(java.lang.String filename)
          throws java.io.IOException
```
    Saves the network in a file.
    
    Parameters:
    
    filename - File in which the network is saved
    
    Throws:
    
    java.io.IOException - Could not write to the file
    
    See Also:
    
    load(String filename)
  - getNNodes
```
public int getNNodes()
```
    Returns the number of nodes.
    
    Returns:
    
    Number of nodes
  - getTotalNodeWeight
```
public double getTotalNodeWeight()
```
    Returns the total node weight.
    
    Returns:
    
    Total node weight
  - getNodeWeights
```
public double[] getNodeWeights()
```
    Returns the weight of each node.
    
    Returns:
    
    Weight of each node
  - getNodeWeight
```
public double getNodeWeight(int node)
```
    Returns the weight of a node.
    
    Parameters:
    
    node - Node
    
    Returns:
    
    Weight
  - getNEdges
```
public long getNEdges()
```
    Returns the number of edges.
    Each edge is counted only once, even though an edge runs in two directions. This means that the number of edges returned by getEdges() equals twice the number of edges returned by getNEdges().
    
    Returns:
    
    Number of edges
  - getNNeighborsPerNode
```
public int[] getNNeighborsPerNode()
```
    Returns the number of neighbors per node.
    
    Returns:
    
    Number of neighbors per node
  - getNNeighbors
```
public int getNNeighbors(int node)
```
    Returns the number of neighbors of a node.
    
    Parameters:
    
    node - Node
    
    Returns:
    
    Number of neighbors
  - getEdges
```
public LargeIntArray[] getEdges()
```
    Returns the list of edges.
    Each edge is included twice, once in each direction. This means that the number of edges returned by getEdges() equals twice the number of edges returned by getNEdges().
    
    The list of edges is returned in a two-dimensional array edges. Edge i connects nodes edges[0].get(i) and edges[1].get(i).
    
    Returns:
    
    List of edges
  - getNeighborsPerNode
```
public int[][] getNeighborsPerNode()
```
    Returns a list of neighbors per node.
    
    Returns:
    
    List of neighbors per node
  - getNeighbors
```
public int[] getNeighbors(int node)
```
    Returns the list of neighbors of a node.
    
    Parameters:
    
    node - Node
    
    Returns:
    
    List of neighbors
  - neighbors
```
public LargeIntArray.FromToIterable neighbors(int node)
```
    Returns an iterable over all the neighbors of a node.
    
    Parameters:
    
    node - Node
    
    Returns:
    
    Iterable over neighbors
  - incidentEdges
```
public Network.RangeIterable incidentEdges(int node)
```
    Returns an iterable over all the incident edges of a node.
    
    Parameters:
    
    node - Node
    
    Returns:
    
    Iterable over incident edges
  - getTotalEdgeWeight
```
public double getTotalEdgeWeight()
```
    Returns the total edge weight.
    Each edge is considered only once, even though an edge runs in two directions. This means that the sum of the edge weights returned by getEdgeWeights() equals twice the total edge weight returned by getTotalEdgeWeight().
    
    Edge weights of self links are not included.
    
    Returns:
    
    Total edge weight
  - getTotalEdgeWeightPerNode
```
public double[] getTotalEdgeWeightPerNode()
```
    Returns the total edge weight per node. The total edge weight of a node equals the sum of the weights of the edges between the node and its neighbors.
    
    Returns:
    
    Total edge weight per node
  - getTotalEdgeWeight
```
public double getTotalEdgeWeight(int node)
```
    Returns the total edge weight of a node. The total edge weight of a node equals the sum of the weights of the edges between the node and its neighbors.
    
    Parameters:
    
    node - Node
    
    Returns:
    
    Total edge weight
  - getEdgeWeights
```
public LargeDoubleArray getEdgeWeights()
```
    Returns the edge weights.
    Each edge is included twice, once in each direction. This means that the sum of the edge weights returned by getEdgeWeights() equals twice the total edge weight returned by getTotalEdgeWeight().
    
    Returns:
    
    Edge weights
  - getEdgeWeightsPerNode
```
public double[][] getEdgeWeightsPerNode()
```
    Returns a list of edge weights per node. These are the weights of the edges between a node and its neighbors.
    
    Returns:
    
    List of edge weights per node
  - getEdgeWeights
```
public double[] getEdgeWeights(int node)
```
    Returns the list of edge weights of a node. These are the weights of the edges between the node and its neighbors.
    
    Parameters:
    
    node - Node
    
    Returns:
    
    List of edge weights
  - edgeWeights
```
public LargeDoubleArray.FromToIterable edgeWeights(int node)
```
    Returns an iterable over all the edge weights of all incident edges of a node.
    
    Parameters:
    
    node - Node
    
    Returns:
    
    Iterable over edge weights of a node
  - getTotalEdgeWeightSelfLinks
```
public double getTotalEdgeWeightSelfLinks()
```
    Returns the total edge weight of self links.
    
    Returns:
    
    Total edge weight of self links
  - createNetworkWithoutNodeWeights
```
public Network createNetworkWithoutNodeWeights()
```
    Creates a copy of the network, but without node weights.
    Each node is assigned a weight of 1.
    
    Returns:
    
    Network without node weights
  - createNetworkWithoutEdgeWeights
```
public Network createNetworkWithoutEdgeWeights()
```
    Creates a copy of the network, but without edge weights.
    Each edge is assigned a weight of 1.
    
    Returns:
    
    Network without edge weights
  - createNetworkWithoutNodeAndEdgeWeights
```
public Network createNetworkWithoutNodeAndEdgeWeights()
```
    Creates a copy of the network, but without node and edge weights.
    Each node is assigned a weight of 1, and each edge is assigned a weight of 1.
    
    Returns:
    
    Network without node and edge weights
  - createNormalizedNetworkUsingAssociationStrength
```
public Network createNormalizedNetworkUsingAssociationStrength()
```
    Creates a copy of the network in which the edge weights have been normalized using the association strength.
    The normalized weight a'[i][j] of the edge between nodes i and j is given by
    
    a'[i][j] = a[i][j] / (n[i] * n[j] / (2 * m)),
    
    where a[i][j] is the non-normalized weight of the edge between nodes i and j, n[i] is the weight of node i, and m is half the total node weight.
    
    If each node's weight equals the total weight of the edges between the node and its neighbors, the edge weights are normalized by dividing them by the expected edge weights in the random configuration model.
    
    The node weights are set to 1.
    
    Returns:
    
    Normalized network
  - createNormalizedNetworkUsingFractionalization
```
public Network createNormalizedNetworkUsingFractionalization()
```
    Creates a copy of the network in which the edge weights have been normalized using fractionalization.
    The normalized weight a'[i][j] of the edge between nodes i and j is given by
    
    a'[i][j] = a[i][j] * (n / n[i] + n / n[j]) / 2,
    
    where a[i][j] is the non-normalized weight of the edge between nodes i and j, n[i] is the weight of node i, and n is the number of nodes.
    
    The node weights are set to 1.
    
    Returns:
    
    Normalized network
  - createPrunedNetwork
```
public Network createPrunedNetwork(int maxNEdges)
```
    Creates a copy of the network that has been pruned in order to have a specified maximum number of edges.
    Only the edges with the highest weights are retained in the pruned network. In case of ties, the edges to be retained are selected randomly.
    
    Parameters:
    
    maxNEdges - Maximum number of edges
    
    Returns:
    
    Pruned network
  - createPrunedNetwork
```
public Network createPrunedNetwork(long maxNEdges,
                                   java.util.Random random)
```
    Creates a copy of the network that has been pruned in order to have a specified maximum number of edges.
    Only the edges with the highest weights are retained in the pruned network. In case of ties, the edges to be retained are selected randomly.
    
    Parameters:
    
    maxNEdges - Maximum number of edges
    
    random - Random number generator
    
    Returns:
    
    Pruned network
  - createSubnetwork
```
public Network createSubnetwork(int[] nodes)
```
    Creates an induced subnetwork for specified nodes.
    
    Parameters:
    
    nodes - Nodes
    
    Returns:
    
    Subnetwork
  - createSubnetwork
```
public Network createSubnetwork(boolean[] nodesInSubnetwork)
```
    Creates an induced subnetwork for specified nodes.
    
    Parameters:
    
    nodesInSubnetwork - Indicates the nodes to be included in the subnetwork.
    
    Returns:
    
    Subnetwork
  - createSubnetwork
```
public Network createSubnetwork(Clustering clustering,
                                int cluster)
```
    Creates an induced subnetwork for a specified cluster in a clustering.
    If subnetworks need to be created for all clusters in a clustering, it is more efficient to use createSubnetworks(Clustering clustering).
    
    Parameters:
    
    clustering - Clustering
    
    cluster - Cluster
    
    Returns:
    
    Subnetwork
  - createSubnetworks
```
public Network[] createSubnetworks(Clustering clustering)
```
    Creates induced subnetworks for the clusters in a clustering.
    
    Parameters:
    
    clustering - Clustering
    
    Returns:
    
    Subnetworks
  - createSubnetworkLargestComponent
```
public Network createSubnetworkLargestComponent()
```
    Creates an induced subnetwork of the largest connected component.
    
    Returns:
    
    Subnetwork
  - createReducedNetwork
```
public Network createReducedNetwork(Clustering clustering)
```
    Creates a reduced (or aggregate) network based on a clustering.
    Each node in the reduced network corresponds to a cluster of nodes in the original network. The weight of a node in the reduced network equals the sum of the weights of the nodes in the corresponding cluster in the original network. The weight of an edge between two nodes in the reduced network equals the sum of the weights of the edges between the nodes in the two corresponding clusters in the original network.
    
    Parameters:
    
    clustering - Clustering
    
    Returns:
    
    Reduced network
  - identifyComponents
```
public Clustering identifyComponents()
```
    Identifies the connected components of the network.
    
    Returns:
    
    Connected components
  - checkIntegrity
```
public void checkIntegrity()
                    throws java.lang.IllegalArgumentException
```
    Checks the integrity of the network.
    It is checked whether:
    - variables have a correct value,
    - arrays have a correct length,
    - edges are sorted correctly,
    - edges are stored in both directions.
    An exception is thrown if the integrity of the network is violated.
    Throws:
    
    java.lang.IllegalArgumentException - An illegal argument was provided in the construction of the network.
  - sortEdges
```
public static void sortEdges(LargeIntArray[] edges,
                             LargeDoubleArray edgeWeights)
```
    Sorts a list of edges and the corresponding edge weights.
    
    Parameters:
    
    edges - Edge list
    
    edgeWeights - Edge weights

Class Network

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

nNodes

nEdges

nodeWeights

firstNeighborIndices

neighbors

edgeWeights

totalEdgeWeightSelfLinks

Constructor Detail

Network

Network

Network

Network

Network

Network

Network

Network

Method Detail

load

save

getNNodes

getTotalNodeWeight

getNodeWeights

getNodeWeight

getNEdges

getNNeighborsPerNode

getNNeighbors

getEdges

getNeighborsPerNode

getNeighbors

neighbors

incidentEdges

getTotalEdgeWeight

getTotalEdgeWeightPerNode

getTotalEdgeWeight

getEdgeWeights

getEdgeWeightsPerNode

getEdgeWeights

edgeWeights

getTotalEdgeWeightSelfLinks

createNetworkWithoutNodeWeights

createNetworkWithoutEdgeWeights

createNetworkWithoutNodeAndEdgeWeights

createNormalizedNetworkUsingAssociationStrength

createNormalizedNetworkUsingFractionalization

createPrunedNetwork

createPrunedNetwork

createSubnetwork

createSubnetwork

createSubnetwork

createSubnetworks

createSubnetworkLargestComponent

createReducedNetwork

identifyComponents

checkIntegrity

sortEdges