graphNEL-class {graph} | R Documentation

## Class "graphNEL"

### Description

This is a class of graphs that are represented in terms of nodes and an edge list. This is a suitable representation for a graph with a large number of nodes and relatively few edges.

### Details

The `graphNEL` class provides a very general structure for representing graphs. It will be reasonably efficient for lists with relatively more nodes than edges. Although this representation can support multi-edges, such support is not implemented and instances of `graphNEL` are assumed to be simple graphs with at most one edge between any pair of nodes.

The `edgeL` is a named `list` of the same length as the node vector. The names are the names of the nodes. Each element of `edgeL` is itself a list. Each element of this (sub)list is a vector (all must be the same length) and each element represents an edge to another node. The sublist named `edges` holds index values into the node vector. And each such entry represents an edge from the node which has the same name as the component of `edgeL` to the node with index provided. Another component that is often used is named `weights`. It represents edge weights. The user can specify any other edge attributes (such as types etc). They are responsible for any special handling that these might require.

For an `undirected` instance all edges are reciprocated (there is an edge from A to B and from B to A).

Note that the reason for using indices to represent the `to` end of a node is so that we can easily support permutation of the node labels as a way to generate randomizations of the graph.

### Slots

`nodes`:

  Object of class `"vector"`.

`edgeL`:

  Object of class `"list"`. The `edgeL` must be the same length as `nodes`. The elements of this vector correspond to the same element in `nodes`. The elements are themselves lists. If the node has any edges then this list will have an element named `edges`. This will eventually change. Since edge weights are now stored in the edge attributes construct, we do not need the extra level of list.

### Extends

Class `"graph"`, directly.

### Constructor

`graphNEL(nodes=character(), edgeL=list(), edgemode='undirected')` creates a graphNEL instance.

nodes

  A character vector of node labels.

edgeL

  A named list either in the format returned by the `edges` method or a list of lists where each inner list has an element named `edges` and optionally an element named `weights`. If `weights` is present, it must be the same length as the `edges` element.

edgemode

  Either "directed" or "undirected".

### Methods

adj

  `signature(object = "graphNEL")`: A method for finding nodes adjacent to the suplied node.

edgeL

  `signature(graph = "graphNEL")`: A method for obtaining the edge list.

edgeWeights

  `signature(object = "graphNEL")`: A method for obtaining the edge weights.

edges

  `signature(object = "graphNEL")`: A method for obtaining the edges.

inEdges

  `signature(node = "character", object = "graphNEL")`: Return the incoming edges for the specified nodes. See `inEdges`.

nodes

  `signature(object = "graphNEL")`: A method for obtaining the nodes.

numNodes

  `signature(object = "graphNEL")`:A method for determining how many nodes are in the graph.

subGraph

  `signature(snodes="character", graph = "graphNEL")`:A method for obtaining the induced subgraph based on the set of supplied nodes and the supplied graph.

plot

  Please see the help page for `plot.graphNEL` in the `Rgraphviz` package

graph2graphviz

  `signature(object = "graphNEL")`: A method that will convert a `graphNEL` object into a matrix suitable for interaction with `Rgraphviz`. Not intended to be called directly. This function will insure that no NA's (or other undesired values) are in the graph, or created by coersion.

nodes<-

  `signature(object="graphNEL", value="character")`: A method for replacing the nodes in a graph object. It checks to be sure the values are the right length and unique.

coerce

  `signature(from = "graphNEL", to = "graphAM")`: Called via `as`, the method converts to an adjacency matrix representation. See `graphAM-class`.

coerce

  `signature(from = "graphNEL", to = "graphBAM")`: Called via `as`, the method converts to an bit array representation. See `graphBAM-class`.

### Author(s)

R. Gentleman

### See Also

`graphAM-class`, `distGraph-class`, `clusterGraph-class`

### Examples

       set.seed(123)
       V <- LETTERS[1:4]
       edL <- vector("list", length=4)
       names(edL) <- V
       for(i in 1:4)
          edL[[i]] <- list(edges=5-i, weights=runif(1))
       gR <- graphNEL(nodes=V, edgeL=edL)
       edges(gR)
       edgeWeights(gR)

[Package graph version 1.65.3 Index]