在第3个暗区中分离矩阵。 R中的3D数组

Question

I have a list of 3D arrays which looks like this:

my.arrs <- list(array(1:5, c(5,4,2)),array(1:5, c(5,4,2)),array(1:5, c(5,4,2))); 
my.arrs

What I wish to have is a new list with each matrix contained in my list of arrays separated (ideally it should look like this):

my.new.matrices (list of 6)
my.array[[1]][1]
my.array[[1]][2]
my.array[[2]][1]
my.array[[2]][2]
my.array[[3]][1]
my.array[[3]][2]

Before having this issue, I worked on something very similar. I had this as the result of a simulation I run in R:

    > TBM
    , , 1

                 [,1]         [,2]        [,3]        [,4]         [,5]         [,6]         [,7]        
     [1,]  0.05151012  0.345498935  0.26056614  0.04567956  0.073153163 -0.070264403  0.158124924

, , 2

             [,1]        [,2]         [,3]        [,4]        [,5]        [,6]        [,7]         
 [1,] -0.65883235 -0.43591955 -0.116739746 -0.28835563  0.04351086 -0.03692388  0.60592379

, , 3

           [,1]      [,2]      [,3]      [,4]       [,5]         [,6]        [,7]       
 [1,] 0.2816988 0.3726166 0.4434252 0.4204302  0.2684518  0.454951339  0.64363895 

And I wrote this for() loop:

TBM.vector3 <- list()
for(i in 1:dim(TBM)[3]) {
  print(i)
  TBM.vector3[[i]] <- as.vector(TBM[,,i])
}
TBM.vector3

which makes exactly what I want ie, separate each matrix in the third dimension and store them in a list of vector. I want to automatize this process a list of array like my.arrs .

Answer 1

1) tapply Each of 3 arrays is made up of 2 5x4 matrices so create a long vector out of it all and then grab successive vectors of 5*4 components and turn them into a matrix of the desired shape:

tapply(unlist(my.arrs), gl(3*2, 5*4), matrix, 5)

or more generally:

dims <- dim(my.arrs[[1]])  # c(5, 4, 2)
tapply(unlist(my.arrs), gl(length(my.arrs) * dims[3], prod(dims[1:2])), matrix, dims[1])

2) sapply/lapply Another possibility (where dims is defined above):

c(sapply(my.arrs, function(x) lapply(1:dims[3], function(i) x[,,i])))

Answer 2

If I understand what you are asking for, here is one approach:

unlist(lapply(my.arrs, function(x) {
    lapply(1:dim(x)[3], function(y) {
        x[,,y]
    })
}), recursive = FALSE)
#[[1]]
#     [,1] [,2] [,3] [,4]
#[1,]    1    1    1    1
#[2,]    2    2    2    2
#[3,]    3    3    3    3
#[4,]    4    4    4    4
#[5,]    5    5    5    5
## ...
## ...
#[[6]]
#     [,1] [,2] [,3] [,4]
#[1,]   11   11   11   11
#[2,]   12   12   12   12
#[3,]   13   13   13   13
#[4,]   14   14   14   14
#[5,]   15   15   15   15

---

• The outer lapply iterates over each array
• The inner lapply iterates over each slice (3rd dimension) of each array, so that 2 is not hardcoded into the function
• Calling unlist with recursive = FALSE (which is not the default behavior) expands the lapply(lapply(...)) result from a length 3 list of length 2 lists into a single length 6 list.

---

Data:

my.arrs <- list(
    array(1:5, c(5,4,2)),
    array(6:10, c(5,4,2)),
    array(11:15, c(5,4,2))
)

Answer 3

Thank you @G. Grothendieck and @nrussell for your answers,

I was also working on my one meanwhile, had simular results with unlist() and found what is my actual problem.

The output of the simulation I run for n <- 2 , gives a list of this format (later I want to make it run for a larger data set and 100 of realizations, so let's start small):

TBM List of 3
tbm1: num [1:29, 1:28, 1:2] ...
tbm2: num [1:29, 1:28, 1:2] ...
tbm3: num [1:29, 1:28, 1:2] ... 

... being my output data.

Because I will have a large data set and n <- 100, I can not unlist manually. Thus I wrote this:

TBM.n <- rep(list(matrix(nrow=29, ncol=28)),6)

for(j in 1:length(TBM)){

for(jj in 1:dim(TBM[[i]])[3]){
    print(jj) 

    print(unlist(TBM[[j]][,,jj]))
    TBM.n[[j]] <- unlist(TBM[[j]][,,jj])
  }

}

print(jj) gives:

1
2
1
2
1
2

print(unlist(TBM[[j]][,,jj])) gives my data split as I want. And there here come my actual problem, the storage. When I write:

TBM.n[[j]] <- unlist(TBM[[j]][,,jj])

or

TBM.n[[jj]] <- unlist(TBM[[j]][,,jj])

I got the data stored for tbm1[,,2] , tbm2[,,2] , tbm3[,,2] and tbm2[,,2] , tbm3[,,2] repectively. Until now I did not find a solution for storing the whole 6 matrices. I have the feeling it is an indexing problem, still trying, not solving. Do you have any suggestions ?

Thank you Marion H

---

EDIT Here is my final code I adapted from @nrussel:

TBM.n <- list()
for (i3 in 1){ #in length(TBM)
  TBM.n[[i3]] <- unlist(lapply(TBM, function(x){
    lapply(1:dim(x)[3], function(y){
      x[,,y]
    })
  }), recursive = FALSE
  )
}

The output gives me the desired results:

TBM.n List of 1
  :List of 6
  ..$ tbm11: num[1:29, 1:28] ...
  ..$ tbm12: num[1:29, 1:28] ...
  ..$ tbm21: num[1:29, 1:28] ...
  ..$ tbm22: num[1:29, 1:28] ...
  ..$ tbm31: num[1:29, 1:28] ...
  ..$ tbm32: num[1:29, 1:28] ...

Again thank you for your help !