从列表中存储的多个矩阵创建矩阵（r）

Question

Edit: example data added at the bottom.

I want to combine multiple matrices that I have stored in a hierarchical list. The hierarchical list looks something like this:

Bodies of Water - Sea   - Sea vs Sea   - DataFrame
                                       - Matrix

                        - Sea vs Lake  - DataFrame
                                       - Matrix

                        - Sea vs Pond  - DataFrame
                                       - Matrix

                 - Lake - Lake vs Sea  - DataFrame
                                       - Matrix

                        - Lake vs Lake - DataFrame
                                       - Matrix

                               ...


                        - Pond vs Pond - DataFrame
                                       - Matrix

Ultimately I want to combine the matrices so that they look like this, whereby the names represent a matrix of numbers, pertaining to the parent folder from which they have come. I am of course not striving for a literal table of strings.

   Sea vs Sea   | Sea vs Lake  | Sea vs Pond
----------------|--------------|--------------
   Lake vs Sea  | Lake vs Lake | Lake vs Pond
----------------|--------------|--------------
   Pond vs Sea  | Pond vs Lake | Pond vs Pond

However, I don't know how to do this. As they are in order, I thought a good place to start would be to create a list or array of matrices:

AllMtx <- 'Bodies of Water'$[[i]]"[["Matrix"]]

or

AllMtx <- list.search('Bodies of Water'$[[i]], all(. == Matrix)

Neither of which are even remotely close to working, which isn't helped by the fact I'm struggling to get list.search to return complete lists, not just store every value from objects named "Matrix" in it's own element in a new list.

And then I was thinking I could use this list or array or whatever I made, combine the rbind and cbind commands, and produce a final matrix, eg

cbind(
        (rbind(AllMtx, 1:3)),
        (rbind(AllMtx, 4:6)),
        (rbind(AllMtx, 7:9))
    )

I was hoping this might sort of resemble a sensible way of assembling the matrix, by first clumping '... vs Sea' , '... vs Lake ' and '... vs Pond' into rows, before finally marrying them all together to fit three columns.

Of course I don't really mind how I get my final matrix, but explaining what I'm trying to do often draws useful feedback.

example matrices:

list(AvsA = structure(c(1, 4, 5, 6, 1, 7, 4, 8, 1), .Dim = c(3L, 
3L)), AvsB = structure(c(3, 3, 4, 5, 5, 4, 3, 9, 2), .Dim = c(3L, 
3L)), BvsA = structure(c(2, 9, 3, 4, 5, 5, 4, 3, 3), .Dim = c(3L, 
3L)), BvsB = structure(c(1, 3, 4, 5, 1, 4, 3, 9, 1), .Dim = c(3L, 
3L)))


    "V1" "V2" "V3"          "V1" "V2" "V3"     
"1"  1    6    4        "1"  3    5    3    
"2"  4    1    8        "2"  3    5    9      
"3"  5    7    1        "3"  4    4    2      

    "V1" "V2" "V3"          "V1" "V2" "V3"
"1"  2    4    4        "1"  1    5    3
"2"  9    5    3        "2"  3    1    9
"3"  3    5    3        "3"  4    4    1

example of final matrix:

structure(c(1, 4, 5, 3, 3, 4, 6, 1, 7, 5, 5, 4, 4, 8, 1, 3, 9, 
2, 2, 9, 3, 1, 3, 4, 4, 5, 5, 5, 1, 4, 4, 3, 3, 3, 9, 1), .Dim = c(6L, 
6L))

    "V1" "V2" "V3" "V4" "V5" "V6"
"1"  1    6    4    2    4    4
"2"  4    1    8    9    5    3
"3"  5    7    1    3    5    3
"4"  3    5    3    1    5    3
"5"  3    5    9    3    1    9
"6"  4    4    2    4    4    1

In order to get the above, a combination of rbind and cbind appeared to work. However I am still struggling to consolidate all of my small "matrix" objects into a list.

Answer 1

This should give you an object to then apply proper rwonames and colnames to:

with(matL, rbind( cbind(AvsA, AvsB), cbind(BvsA,BvsB)))
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    6    4    3    5    3
[2,]    4    1    8    3    5    9
[3,]    5    7    1    4    4    2
[4,]    2    4    4    1    5    3
[5,]    9    5    3    3    1    9
[6,]    3    5    3    4    4    1

If this were a much larger structure then you might need to refer to the list elements with numeric indices in which case yoyu might choose to use do.call with cbind and rbind:

with(matL, do.call( rbind, 
                     list( do.call( cbind, matL[1:2]), 
                           do.call( cbind, matL[3:4] ))
                  )
     )
 #------------------------
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    6    4    3    5    3
[2,]    4    1    8    3    5    9
[3,]    5    7    1    4    4    2
[4,]    2    4    4    1    5    3
[5,]    9    5    3    3    1    9
[6,]    3    5    3    4    4    1