graphNEL-class
Class "graphNEL"
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.
- Keywords
- classes
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"
. TheedgeL
must be the same length asnodes
. The elements of this vector correspond to the same element innodes
. The elements are themselves lists. If the node has any edges then this list will have an element namededges
. 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 namededges
and optionally an element namedweights
. Ifweights
is present, it must be the same length as theedges
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. SeeinEdges
.- 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 theRgraphviz
package - graph2graphviz
signature(object = "graphNEL")
: A method that will convert agraphNEL
object into a matrix suitable for interaction withRgraphviz
. 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 viaas
, the method converts to an adjacency matrix representation. SeegraphAM-class
.- coerce
signature(from = "graphNEL", to = "graphBAM")
: Called viaas
, the method converts to an bit array representation. SeegraphBAM-class
.
See Also
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)