returnBlockEdgeList: Class dg.BlockEdgeList: The block edge list
In dynamicGraph: dynamicGraph

Description Usage Arguments Value Slots Extends Methods Note Author(s) Examples

Return a list of block edges, each of class dg.BlockEdge.

Objects can be created by calls of the form new("dg.BlockEdgeList", ...).

1
2
3

returnBlockEdgeList(edge.list, vertices, blocks, 
                    visibleBlocks = 1:length(blocks), width = 2, 
                    color = "default", N = 3, oriented = NA, type = NULL)

`edge.list`	A list of vectors identifying the edges (between vertices). Each vector of `edge.list` should be a vector of integers giving the indices of the vertices of an edge, or a vector of text strings with the names of the vertices.
`vertices`	The list of `vertices`, each of a class containing `dg.Vertex`.
`blocks`	The list of `blocks`, each of a class `dg.Block`.
`visibleBlocks`	A numeric vector with the indices of the `visibleBlocks`. The argument is for view where some blocks are not visible in the view, but the vertices of the blocks are drawn.
`width`	A numeric with the initial `width` of block edges.
`color`	"default", or list with one or two text strings for colors giving the initial `color` of block edges. The two colors are used for respectively edges between blocks and for edges between blocks and vertices.
`N`	Integer, `N` is the number of coordinates of the vertices.
`oriented`	Logical, if TRUE then the edges are `oriented`.
`type`	A text string giving the `type` of block edges.

A list of block edges, each of class dg.BlockEdge.

.Data:: Object of class "list".

Class "dg.EdgeList", directly. Class "dg.list", directly. Class "list", from data part. Class "dg.NodeList", by class "dg.EdgeList". Class "vector", by class "dg.EdgeList". Class "vector", by class "dg.list". Class "vector", by class "list".

initialize: signature(.Object = "dg.BlockEdgeList"): ...
ancestorsBlockList: signature(blockList = "dg.BlockList"): ...
descendantsBlockList: signature(blockList = "dg.BlockList"): ...
checkBlockList: signature(blockList = "dg.BlockList"): ...

The methods of the edge list, returnEdgeList, also applies for block edge lists.

Jens Henrik Badsberg

Block.tree <- list(label = "W", Vertices = c("country"),
                   X = list(Vertices = c("sex", "race"),
                            A = list(Vertices = c("hair", "eye"),
                                     horizontal = FALSE),
                            B = list(Vertices = c("age"),
                                     C = list(Vertices = c("education")))))
Names <- unlist(Block.tree)
Names <- Names[grep("Vertices", names(Names))]
Types <- rep("Discrete", length(Names))
vertices <- returnVertexList(Names, types = Types)
blocktree <- setTreeBlocks(Block.tree, vertices)
blocks <- blockTreeToList(blocktree$BlockTree)
from <- c("country", "country", "race", "race",       "sex", "sex")
to   <- c(    "sex",    "race", "hair",  "eye", "education", "age")
from <- match(from, Names)
to <- match(to, Names)
edge.list <- vector("list", length(to))
for (j in seq(along = to)) edge.list[[j]] <- c(from[j], to[j])
edges <- returnEdgeList(edge.list, vertices, color = "red", oriented = TRUE)
vertices <- blocktree$Vertices
blockedges <- returnBlockEdgeList(edge.list, vertices, blocks,
                                  color = "red", oriented = TRUE)
blockedges <- new("dg.BlockEdgeList", edge.list = edge.list, 
                                      vertices = vertices, blocks = blocks,
                                      color = "red", oriented = TRUE)

Names(blockedges)
Colors(blockedges)
Labels(blockedges)
LabelPositions(blockedges)
# Positions(blockedges)
# Strata(blockedges)
# Indices(blockedges)
str(NodeTypes(blockedges))
str(NodeIndices(blockedges))
Widths(blockedges)
Oriented(blockedges)
Widths(blockedges) <- rep(1,  7)
Widths(blockedges) <- rep(1, 14)
Widths(blockedges)
asDataFrame(blockedges)