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.
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
graphNEL are assumed to be simple graphs with at most one
edge between any pair of nodes.
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.
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
of a node is so that we can easily support permutation of the node
labels as a way to generate randomizations of the graph.
- Object of class
- Object of class
edgeLmust 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.
graphNEL(nodes=character(), edgeL=list(), edgemode='undirected')
creates a graphNEL instance.
- A character vector of node labels.
- A named list either in the format returned by the
edgesmethod or a list of lists where each inner list has an element named
edgesand optionally an element named
weightsis present, it must be the same length as the
- Either "directed" or "undirected".
signature(object = "graphNEL"): A method for finding nodes adjacent to the suplied node.
signature(graph = "graphNEL"): A method for obtaining the edge list.
signature(object = "graphNEL"): A method for obtaining the edge weights.
signature(object = "graphNEL"): A method for obtaining the edges.
signature(node = "character", object = "graphNEL"): Return the incoming edges for the specified nodes. See
signature(object = "graphNEL"): A method for obtaining the nodes.
signature(object = "graphNEL"):A method for determining how many nodes are in the graph.
signature(snodes="character", graph = "graphNEL"):A method for obtaining the induced subgraph based on the set of supplied nodes and the supplied graph.
- Please see the help page for
signature(object = "graphNEL"): A method that will convert a
graphNELobject 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.
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.
signature(from = "graphNEL", to = "graphAM"): Called via
as, the method converts to an adjacency matrix representation. See
signature(from = "graphNEL", to = "graphBAM"): Called via
as, the method converts to an bit array representation. See
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)