graphNEL-class: Class "graphNEL"
In pshannon-bioc/graph: graph: A package to handle graph data structures

Description Details Slots Extends Constructor Methods Author(s) See Also Examples

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.

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.

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.

Class "graph", directly.

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".

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.

R. Gentleman

graphAM-class, distGraph-class, clusterGraph-class

   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)