nodes:"vector".edgeL:"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.
"graph", directly.graphNEL(nodes=character(), edgeL=list(), edgemode='undirected')
creates a graphNEL instance. 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.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 inEdges.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.plot.graphNEL in the
Rgraphviz packagesignature(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.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 graphAM-class. signature(from = "graphNEL", to = "graphBAM"):
Called via as, the method converts to an bit array
representation. See graphBAM-class. 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.
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)
Run the code above in your browser using DataLab