# 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"`

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

.

##### 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)
```

*Documentation reproduced from package graph, version 1.50.0, License: Artistic-2.0*