R Under development (unstable) (2024-02-05 r85863 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2024 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

> library(pcalg)
> ## (doExtras <- pcalg:::doExtras())
> 
> ## NB: add tests in addition to the simple ones from Maathuis and Colombo (2013)
> ## in ../man/backdoor.Rd
> ##    ~~~~~~~~~~~~~~~~~~
> 
> `%w/o%` <- function(x, y) x[!x %in% y] #--  x without y
> ## slightly faster:
> `%w/o%` <- function(x, y) x[!match(x, y, nomatch = 0L)]
> 
> ###-------- DAG ----------------------
> suppressWarnings(RNGversion("3.5.0"))
> set.seed(47)
> ## p <- if(doExtras) 17 else 12
> p <- 12
> myDAG <- randomDAG(p, prob = 1/4) ## true DAG
> 
> ## Extract the adjacency matrix of the true DAG
> true.amat <- (amat <- as(myDAG, "matrix")) != 0 # TRUE/FALSE <==> 1/0
> print.table(1*true.amat, zero.=".") # "visualization"
   1 2 3 4 5 6 7 8 9 10 11 12
1  . . . 1 . 1 . . 1  1  1  1
2  . . . . . 1 . 1 .  .  1  .
3  . . . . . . . . 1  .  .  .
4  . . . . . . . . .  1  .  .
5  . . . . . . . . .  .  .  .
6  . . . . . . . . .  .  .  .
7  . . . . . . . . .  .  1  .
8  . . . . . . . . .  1  .  .
9  . . . . . . . . .  1  1  .
10 . . . . . . . . .  .  1  .
11 . . . . . . . . .  .  .  .
12 . . . . . . . . .  .  .  .
> 
> nodes <- 1:p; names(nodes) <- nodes
> cat("Time for many backdoor(.., \"dag\") s : ", system.time(
+ LL <- lapply(nodes, function(i)
+ 	     lapply(nodes %w/o% i,
+ 		    backdoor,
+ 		    amat = true.amat, x = i, type="dag"))
+ ), "\n")
Time for many backdoor(.., "dag") s :  0.6 0.04 0.64 NA NA 
> 
> ## if(doExtras) {
> ##     for(i in nodes[1:3]) ## Nodes 1,2,3 are all "root" nodes:
> ## 	stopifnot(vapply(LL[[i]], identical, NA, y=integer(0)))
> 
> ##     str(LL[-(1:3)]) ## Martin: interesting.. Q: is "this" known? A: yes, basically
> ## } else {
> ##     str(LL)
> ## }
> str(LL)
List of 12
 $ 1 :List of 11
  ..$ 2 : int(0) 
  ..$ 3 : int(0) 
  ..$ 4 : int(0) 
  ..$ 5 : NULL
  ..$ 6 : int(0) 
  ..$ 7 : int(0) 
  ..$ 8 : int(0) 
  ..$ 9 : int(0) 
  ..$ 10: int(0) 
  ..$ 11: int(0) 
  ..$ 12: int(0) 
 $ 2 :List of 11
  ..$ 1 : int(0) 
  ..$ 3 : int(0) 
  ..$ 4 : int(0) 
  ..$ 5 : NULL
  ..$ 6 : int(0) 
  ..$ 7 : int(0) 
  ..$ 8 : int(0) 
  ..$ 9 : int(0) 
  ..$ 10: int(0) 
  ..$ 11: int(0) 
  ..$ 12: int(0) 
 $ 3 :List of 11
  ..$ 1 : int(0) 
  ..$ 2 : int(0) 
  ..$ 4 : int(0) 
  ..$ 5 : NULL
  ..$ 6 : int(0) 
  ..$ 7 : int(0) 
  ..$ 8 : int(0) 
  ..$ 9 : int(0) 
  ..$ 10: int(0) 
  ..$ 11: int(0) 
  ..$ 12: int(0) 
 $ 4 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : int 1
  ..$ 3 : int 1
  ..$ 5 : NULL
  ..$ 6 : int 1
  ..$ 7 : int 1
  ..$ 8 : int 1
  ..$ 9 : int 1
  ..$ 10: int 1
  ..$ 11: int 1
  ..$ 12: int 1
 $ 5 :List of 11
  ..$ 1 : NULL
  ..$ 2 : NULL
  ..$ 3 : NULL
  ..$ 4 : NULL
  ..$ 6 : NULL
  ..$ 7 : NULL
  ..$ 8 : NULL
  ..$ 9 : NULL
  ..$ 10: NULL
  ..$ 11: NULL
  ..$ 12: NULL
 $ 6 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : logi NA
  ..$ 3 : int [1:2] 1 2
  ..$ 4 : int [1:2] 1 2
  ..$ 5 : NULL
  ..$ 7 : int [1:2] 1 2
  ..$ 8 : int [1:2] 1 2
  ..$ 9 : int [1:2] 1 2
  ..$ 10: int [1:2] 1 2
  ..$ 11: int [1:2] 1 2
  ..$ 12: int [1:2] 1 2
 $ 7 :List of 11
  ..$ 1 : int(0) 
  ..$ 2 : int(0) 
  ..$ 3 : int(0) 
  ..$ 4 : int(0) 
  ..$ 5 : NULL
  ..$ 6 : int(0) 
  ..$ 8 : int(0) 
  ..$ 9 : int(0) 
  ..$ 10: int(0) 
  ..$ 11: int(0) 
  ..$ 12: int(0) 
 $ 8 :List of 11
  ..$ 1 : int 2
  ..$ 2 : logi NA
  ..$ 3 : int 2
  ..$ 4 : int 2
  ..$ 5 : NULL
  ..$ 6 : int 2
  ..$ 7 : int 2
  ..$ 9 : int 2
  ..$ 10: int 2
  ..$ 11: int 2
  ..$ 12: int 2
 $ 9 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : int [1:2] 1 3
  ..$ 3 : logi NA
  ..$ 4 : int [1:2] 1 3
  ..$ 5 : NULL
  ..$ 6 : int [1:2] 1 3
  ..$ 7 : int [1:2] 1 3
  ..$ 8 : int [1:2] 1 3
  ..$ 10: int [1:2] 1 3
  ..$ 11: int [1:2] 1 3
  ..$ 12: int [1:2] 1 3
 $ 10:List of 11
  ..$ 1 : logi NA
  ..$ 2 : int [1:4] 1 4 8 9
  ..$ 3 : int [1:4] 1 4 8 9
  ..$ 4 : logi NA
  ..$ 5 : NULL
  ..$ 6 : int [1:4] 1 4 8 9
  ..$ 7 : int [1:4] 1 4 8 9
  ..$ 8 : logi NA
  ..$ 9 : logi NA
  ..$ 11: int [1:4] 1 4 8 9
  ..$ 12: int [1:4] 1 4 8 9
 $ 11:List of 11
  ..$ 1 : logi NA
  ..$ 2 : logi NA
  ..$ 3 : int [1:5] 1 2 7 9 10
  ..$ 4 : int [1:5] 1 2 7 9 10
  ..$ 5 : NULL
  ..$ 6 : int [1:5] 1 2 7 9 10
  ..$ 7 : logi NA
  ..$ 8 : int [1:5] 1 2 7 9 10
  ..$ 9 : logi NA
  ..$ 10: logi NA
  ..$ 12: int [1:5] 1 2 7 9 10
 $ 12:List of 11
  ..$ 1 : logi NA
  ..$ 2 : int 1
  ..$ 3 : int 1
  ..$ 4 : int 1
  ..$ 5 : NULL
  ..$ 6 : int 1
  ..$ 7 : int 1
  ..$ 8 : int 1
  ..$ 9 : int 1
  ..$ 10: int 1
  ..$ 11: int 1
> 
> ###-------- CPDAG --------------------
> 
> ## estimate the true CPDAG
> myCPDAG <- dag2cpdag(myDAG)
> ## Extract the adjacency matrix of the true CPDAG
> CP.amat <- (as(myCPDAG, "matrix") != 0) # 1/0 <==> TRUE/FALSE
> 
> cat("Time for many backdoor(.., \"cpdag\") s : ", system.time(
+ L2 <- lapply(nodes, function(i)
+ 	     lapply(nodes %w/o% i,
+ 		    backdoor,
+ 		    amat = CP.amat, x = i, type="cpdag"))
+ ), "\n")
Time for many backdoor(.., "cpdag") s :  0.93 0.02 0.93 NA NA 
> 
> str(L2)
List of 12
 $ 1 :List of 11
  ..$ 2 : int(0) 
  ..$ 3 : int(0) 
  ..$ 4 : logi NA
  ..$ 5 : NULL
  ..$ 6 : int(0) 
  ..$ 7 : int(0) 
  ..$ 8 : int(0) 
  ..$ 9 : int(0) 
  ..$ 10: logi NA
  ..$ 11: logi NA
  ..$ 12: logi NA
 $ 2 :List of 11
  ..$ 1 : int(0) 
  ..$ 3 : int(0) 
  ..$ 4 : int(0) 
  ..$ 5 : NULL
  ..$ 6 : int(0) 
  ..$ 7 : int(0) 
  ..$ 8 : logi NA
  ..$ 9 : int(0) 
  ..$ 10: logi NA
  ..$ 11: logi NA
  ..$ 12: int(0) 
 $ 3 :List of 11
  ..$ 1 : int(0) 
  ..$ 2 : int(0) 
  ..$ 4 : int(0) 
  ..$ 5 : NULL
  ..$ 6 : int(0) 
  ..$ 7 : int(0) 
  ..$ 8 : int(0) 
  ..$ 9 : int(0) 
  ..$ 10: int(0) 
  ..$ 11: int(0) 
  ..$ 12: int(0) 
 $ 4 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : int(0) 
  ..$ 3 : int(0) 
  ..$ 5 : NULL
  ..$ 6 : logi NA
  ..$ 7 : int(0) 
  ..$ 8 : int(0) 
  ..$ 9 : logi NA
  ..$ 10: logi NA
  ..$ 11: logi NA
  ..$ 12: logi NA
 $ 5 :List of 11
  ..$ 1 : NULL
  ..$ 2 : NULL
  ..$ 3 : NULL
  ..$ 4 : NULL
  ..$ 6 : NULL
  ..$ 7 : NULL
  ..$ 8 : NULL
  ..$ 9 : NULL
  ..$ 10: NULL
  ..$ 11: NULL
  ..$ 12: NULL
 $ 6 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : logi NA
  ..$ 3 : int [1:2] 1 2
  ..$ 4 : int [1:2] 1 2
  ..$ 5 : NULL
  ..$ 7 : int [1:2] 1 2
  ..$ 8 : int [1:2] 1 2
  ..$ 9 : int [1:2] 1 2
  ..$ 10: int [1:2] 1 2
  ..$ 11: int [1:2] 1 2
  ..$ 12: int [1:2] 1 2
 $ 7 :List of 11
  ..$ 1 : int(0) 
  ..$ 2 : int(0) 
  ..$ 3 : int(0) 
  ..$ 4 : int(0) 
  ..$ 5 : NULL
  ..$ 6 : int(0) 
  ..$ 8 : int(0) 
  ..$ 9 : int(0) 
  ..$ 10: int(0) 
  ..$ 11: int(0) 
  ..$ 12: int(0) 
 $ 8 :List of 11
  ..$ 1 : int(0) 
  ..$ 2 : logi NA
  ..$ 3 : int(0) 
  ..$ 4 : int(0) 
  ..$ 5 : NULL
  ..$ 6 : logi NA
  ..$ 7 : int(0) 
  ..$ 9 : int(0) 
  ..$ 10: int(0) 
  ..$ 11: logi NA
  ..$ 12: int(0) 
 $ 9 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : int [1:2] 1 3
  ..$ 3 : logi NA
  ..$ 4 : int [1:2] 1 3
  ..$ 5 : NULL
  ..$ 6 : int [1:2] 1 3
  ..$ 7 : int [1:2] 1 3
  ..$ 8 : int [1:2] 1 3
  ..$ 10: int [1:2] 1 3
  ..$ 11: int [1:2] 1 3
  ..$ 12: int [1:2] 1 3
 $ 10:List of 11
  ..$ 1 : logi NA
  ..$ 2 : int [1:4] 1 4 8 9
  ..$ 3 : int [1:4] 1 4 8 9
  ..$ 4 : logi NA
  ..$ 5 : NULL
  ..$ 6 : int [1:4] 1 4 8 9
  ..$ 7 : int [1:4] 1 4 8 9
  ..$ 8 : logi NA
  ..$ 9 : logi NA
  ..$ 11: int [1:4] 1 4 8 9
  ..$ 12: int [1:4] 1 4 8 9
 $ 11:List of 11
  ..$ 1 : logi NA
  ..$ 2 : logi NA
  ..$ 3 : int [1:5] 1 2 7 9 10
  ..$ 4 : int [1:5] 1 2 7 9 10
  ..$ 5 : NULL
  ..$ 6 : int [1:5] 1 2 7 9 10
  ..$ 7 : logi NA
  ..$ 8 : int [1:5] 1 2 7 9 10
  ..$ 9 : logi NA
  ..$ 10: logi NA
  ..$ 12: int [1:5] 1 2 7 9 10
 $ 12:List of 11
  ..$ 1 : logi NA
  ..$ 2 : int(0) 
  ..$ 3 : int(0) 
  ..$ 4 : logi NA
  ..$ 5 : NULL
  ..$ 6 : logi NA
  ..$ 7 : int(0) 
  ..$ 8 : int(0) 
  ..$ 9 : logi NA
  ..$ 10: logi NA
  ..$ 11: logi NA
> 
> 
> ###-------- PAG ----------------------
> 
> ## define nodes 2 and 6 to be latent variables
> L <- c(2,6)
> 
> ## compute the true covariance matrix of g
> cov.mat <- trueCov(myDAG)
> ## transform covariance matrix into a correlation matrix
> true.corr <- cov2cor(cov.mat)
> 
> ## find PAG
> ## as dependence "oracle", we use the true correlation matrix in
> ## gaussCItest() with a large "virtual sample size" and a large alpha:
> true.pag <- dag2pag(suffStat = list(C = true.corr, n = 10^9),
+                     indepTest = gaussCItest,
+                     graph=myDAG, L=L, alpha = 0.9999)
> PAG.amat <- true.pag@amat # {0 1 2 3}
> 
> cat("Time for many backdoor(.., \"pag\") s : ", system.time(
+ L3 <- lapply(nodes, function(i)
+ 	     lapply(nodes %w/o% i,
+ 		    backdoor,
+ 		    amat = PAG.amat, x = i, type="pag"))
+ ), "\n")
Time for many backdoor(.., "pag") s :  0.62 0 0.63 NA NA 
> 
> str(L3)
List of 12
 $ 1 :List of 11
  ..$ 2 : int(0) 
  ..$ 3 : logi NA
  ..$ 4 : NULL
  ..$ 5 : int(0) 
  ..$ 6 : int(0) 
  ..$ 7 : logi NA
  ..$ 8 : logi NA
  ..$ 9 : logi NA
  ..$ 10: logi NA
  ..$ 11: NULL
  ..$ 12: NULL
 $ 2 :List of 11
  ..$ 1 : int(0) 
  ..$ 3 : int(0) 
  ..$ 4 : NULL
  ..$ 5 : int(0) 
  ..$ 6 : int(0) 
  ..$ 7 : logi NA
  ..$ 8 : logi NA
  ..$ 9 : logi NA
  ..$ 10: int(0) 
  ..$ 11: NULL
  ..$ 12: NULL
 $ 3 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : int(0) 
  ..$ 4 : NULL
  ..$ 5 : int(0) 
  ..$ 6 : int(0) 
  ..$ 7 : logi NA
  ..$ 8 : logi NA
  ..$ 9 : logi NA
  ..$ 10: logi NA
  ..$ 11: NULL
  ..$ 12: NULL
 $ 4 :List of 11
  ..$ 1 : NULL
  ..$ 2 : NULL
  ..$ 3 : NULL
  ..$ 5 : NULL
  ..$ 6 : NULL
  ..$ 7 : NULL
  ..$ 8 : NULL
  ..$ 9 : NULL
  ..$ 10: NULL
  ..$ 11: NULL
  ..$ 12: NULL
 $ 5 :List of 11
  ..$ 1 : int(0) 
  ..$ 2 : int(0) 
  ..$ 3 : int(0) 
  ..$ 4 : NULL
  ..$ 6 : int(0) 
  ..$ 7 : int(0) 
  ..$ 8 : int(0) 
  ..$ 9 : logi NA
  ..$ 10: int(0) 
  ..$ 11: NULL
  ..$ 12: NULL
 $ 6 :List of 11
  ..$ 1 : int(0) 
  ..$ 2 : int(0) 
  ..$ 3 : int(0) 
  ..$ 4 : NULL
  ..$ 5 : int(0) 
  ..$ 7 : int(0) 
  ..$ 8 : logi NA
  ..$ 9 : logi NA
  ..$ 10: int(0) 
  ..$ 11: NULL
  ..$ 12: NULL
 $ 7 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : logi NA
  ..$ 3 : int [1:2] 1 2
  ..$ 4 : NULL
  ..$ 5 : int [1:2] 1 2
  ..$ 6 : int [1:2] 1 2
  ..$ 8 : int [1:2] 1 2
  ..$ 9 : int [1:2] 1 2
  ..$ 10: int [1:2] 1 2
  ..$ 11: NULL
  ..$ 12: NULL
 $ 8 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : int [1:4] 1 3 6 7
  ..$ 3 : logi NA
  ..$ 4 : NULL
  ..$ 5 : int [1:4] 1 3 6 7
  ..$ 6 : logi NA
  ..$ 7 : logi NA
  ..$ 9 : int [1:4] 1 3 6 7
  ..$ 10: int [1:4] 1 3 6 7
  ..$ 11: NULL
  ..$ 12: NULL
 $ 9 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : int [1:5] 1 5 6 7 8
  ..$ 3 : int [1:5] 1 5 6 7 8
  ..$ 4 : NULL
  ..$ 5 : logi NA
  ..$ 6 : logi NA
  ..$ 7 : logi NA
  ..$ 8 : logi NA
  ..$ 10: int [1:5] 1 5 6 7 8
  ..$ 11: NULL
  ..$ 12: NULL
 $ 10:List of 11
  ..$ 1 : logi NA
  ..$ 2 : int(0) 
  ..$ 3 : logi NA
  ..$ 4 : NULL
  ..$ 5 : int(0) 
  ..$ 6 : int(0) 
  ..$ 7 : logi NA
  ..$ 8 : logi NA
  ..$ 9 : logi NA
  ..$ 11: NULL
  ..$ 12: NULL
 $ 11:List of 11
  ..$ 1 : NULL
  ..$ 2 : NULL
  ..$ 3 : NULL
  ..$ 4 : NULL
  ..$ 5 : NULL
  ..$ 6 : NULL
  ..$ 7 : NULL
  ..$ 8 : NULL
  ..$ 9 : NULL
  ..$ 10: NULL
  ..$ 12: NULL
 $ 12:List of 11
  ..$ 1 : NULL
  ..$ 2 : NULL
  ..$ 3 : NULL
  ..$ 4 : NULL
  ..$ 5 : NULL
  ..$ 6 : NULL
  ..$ 7 : NULL
  ..$ 8 : NULL
  ..$ 9 : NULL
  ..$ 10: NULL
  ..$ 11: NULL
> 
> 
> ###-------- MAG ----------------------
> 
> 
> ## find a valid MAG such that no additional edges are directed into
> (MAG.amat <- pag2magAM(PAG.amat, 4))
   1 2 3 4 5 6 7 8 9 10
1  0 0 2 0 0 0 2 2 2  3
2  0 0 0 0 0 0 2 0 0  0
3  3 0 0 0 0 0 0 2 0  0
4  0 0 0 0 0 0 0 0 0  0
5  0 0 0 0 0 0 0 0 2  0
6  0 0 0 0 0 0 0 2 2  0
7  3 3 0 0 0 0 0 2 2  0
8  3 0 3 0 0 3 3 0 2  0
9  3 0 0 0 3 3 3 3 0  0
10 2 0 0 0 0 0 0 0 0  0
> 
> cat("Time for many backdoor(.., \"mag\") s : ", system.time(
+ L4 <- lapply(nodes, function(i)
+ 	     lapply(nodes %w/o% i,
+ 		    backdoor,
+ 		    amat = MAG.amat, x = i, type="mag"))
+ ), "\n")
Time for many backdoor(.., "mag") s :  0.37 0 0.38 NA NA 
> ## actually this is the *fastest* of the cases
> 
> str(L4)
List of 12
 $ 1 :List of 11
  ..$ 2 : int 10
  ..$ 3 : int 10
  ..$ 4 : NULL
  ..$ 5 : int 10
  ..$ 6 : int 10
  ..$ 7 : int 10
  ..$ 8 : int 10
  ..$ 9 : int 10
  ..$ 10: logi NA
  ..$ 11: NULL
  ..$ 12: NULL
 $ 2 :List of 11
  ..$ 1 : int(0) 
  ..$ 3 : int(0) 
  ..$ 4 : NULL
  ..$ 5 : int(0) 
  ..$ 6 : int(0) 
  ..$ 7 : logi NA
  ..$ 8 : logi NA
  ..$ 9 : logi NA
  ..$ 10: int(0) 
  ..$ 11: NULL
  ..$ 12: NULL
 $ 3 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : int 1
  ..$ 4 : NULL
  ..$ 5 : int 1
  ..$ 6 : int 1
  ..$ 7 : int 1
  ..$ 8 : logi NA
  ..$ 9 : logi NA
  ..$ 10: int 1
  ..$ 11: NULL
  ..$ 12: NULL
 $ 4 :List of 11
  ..$ 1 : NULL
  ..$ 2 : NULL
  ..$ 3 : NULL
  ..$ 5 : NULL
  ..$ 6 : NULL
  ..$ 7 : NULL
  ..$ 8 : NULL
  ..$ 9 : NULL
  ..$ 10: NULL
  ..$ 11: NULL
  ..$ 12: NULL
 $ 5 :List of 11
  ..$ 1 : int(0) 
  ..$ 2 : int(0) 
  ..$ 3 : int(0) 
  ..$ 4 : NULL
  ..$ 6 : int(0) 
  ..$ 7 : int(0) 
  ..$ 8 : int(0) 
  ..$ 9 : logi NA
  ..$ 10: int(0) 
  ..$ 11: NULL
  ..$ 12: NULL
 $ 6 :List of 11
  ..$ 1 : int(0) 
  ..$ 2 : int(0) 
  ..$ 3 : int(0) 
  ..$ 4 : NULL
  ..$ 5 : int(0) 
  ..$ 7 : int(0) 
  ..$ 8 : logi NA
  ..$ 9 : logi NA
  ..$ 10: int(0) 
  ..$ 11: NULL
  ..$ 12: NULL
 $ 7 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : logi NA
  ..$ 3 : int [1:2] 1 2
  ..$ 4 : NULL
  ..$ 5 : int [1:2] 1 2
  ..$ 6 : int [1:2] 1 2
  ..$ 8 : int [1:2] 1 2
  ..$ 9 : int [1:2] 1 2
  ..$ 10: int [1:2] 1 2
  ..$ 11: NULL
  ..$ 12: NULL
 $ 8 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : int [1:4] 1 3 6 7
  ..$ 3 : logi NA
  ..$ 4 : NULL
  ..$ 5 : int [1:4] 1 3 6 7
  ..$ 6 : logi NA
  ..$ 7 : logi NA
  ..$ 9 : int [1:4] 1 3 6 7
  ..$ 10: int [1:4] 1 3 6 7
  ..$ 11: NULL
  ..$ 12: NULL
 $ 9 :List of 11
  ..$ 1 : logi NA
  ..$ 2 : int [1:5] 1 5 6 7 8
  ..$ 3 : int [1:5] 1 5 6 7 8
  ..$ 4 : NULL
  ..$ 5 : logi NA
  ..$ 6 : logi NA
  ..$ 7 : logi NA
  ..$ 8 : logi NA
  ..$ 10: int [1:5] 1 5 6 7 8
  ..$ 11: NULL
  ..$ 12: NULL
 $ 10:List of 11
  ..$ 1 : logi NA
  ..$ 2 : int(0) 
  ..$ 3 : logi NA
  ..$ 4 : NULL
  ..$ 5 : int(0) 
  ..$ 6 : int(0) 
  ..$ 7 : logi NA
  ..$ 8 : logi NA
  ..$ 9 : logi NA
  ..$ 11: NULL
  ..$ 12: NULL
 $ 11:List of 11
  ..$ 1 : NULL
  ..$ 2 : NULL
  ..$ 3 : NULL
  ..$ 4 : NULL
  ..$ 5 : NULL
  ..$ 6 : NULL
  ..$ 7 : NULL
  ..$ 8 : NULL
  ..$ 9 : NULL
  ..$ 10: NULL
  ..$ 12: NULL
 $ 12:List of 11
  ..$ 1 : NULL
  ..$ 2 : NULL
  ..$ 3 : NULL
  ..$ 4 : NULL
  ..$ 5 : NULL
  ..$ 6 : NULL
  ..$ 7 : NULL
  ..$ 8 : NULL
  ..$ 9 : NULL
  ..$ 10: NULL
  ..$ 11: NULL
> 
> proc.time()
   user  system elapsed 
   4.20    0.25    4.43