# [R] A question to get all possible combinations

(Ted Harding) ted.harding at wlandres.net
Wed Dec 22 23:39:05 CET 2010

```On 22-Dec-10 18:19:38, Ron Michael wrote:
> Let say, I have a matrix with 8 rows and 6 columns:_
> df1 <- matrix(NA, 8, 4)
> df1
>      [,1] [,2] [,3] [,4]
> [1,]   NA   NA   NA   NA
> [2,]   NA   NA   NA   NA
> [3,]   NA   NA   NA   NA
> [4,]   NA   NA   NA   NA
> [5,]   NA   NA   NA   NA
> [6,]   NA   NA   NA   NA
> [7,]   NA   NA   NA   NA
> [8,]   NA   NA   NA   NA
>
> Now I want to get **all possible** ways to fetch 6 cells at
> a time. Is there any function to do that?
> Thanks,

If you just want all possible sets of 6 values (i.e. the values
at 6 different cells, for all possible choices of 6 out of 8*4 = 32)
then it is straightforward enough using the combn() function.
I give a smaller example to show the principle. You get the 20 ways
of choosing the values in 3 different cells of a 6-cell (3*2) matrix:

df1 <- matrix((1:6),ncol=2)
df1
#      [,1] [,2]
# [1,]    1    4
# [2,]    2    5
# [3,]    3    6

combn(df1,3)
[,1]  [,2]  [,3]  [,4]  [,5]  [,6]  [,7]  [,8]  [,9] [,10]
[1,]     1     1     1     1     1     1     1     1     1     1
[2,]     2     2     2     2     3     3     3     4     4     5
[3,]     3     4     5     6     4     5     6     5     6     6
[,11] [,12] [,13] [,14] [,15] [,16] [,17] [,18] [,19] [,20]
[1,]     2     2     2     2     2     2     3     3     3     4
[2,]     3     3     3     4     4     5     4     4     5     5
[3,]     4     5     6     5     6     6     5     6     6     6

This basically works because the elements of a matrix are stored
linearly (1->2->3->4->5->6) down the columns, with a "dim" attribute
to sort out the indexing by rows and columns. combn(df1,3) then
picks out all sets of 3 from these 6 and returns the results in
"natural" order.

However, this result loses all information about the row-column
indexing of the values which are returned.

Getting at this is a little trickier. There may be some function
which can do it directly, though I don't know of one. An alternative
(the least subtle I can think of ... ) could be to do the same combn()
operation on vectors which gives the rows and columns of the elements
in the matrix df1:

The result of combn() is a list, as above, and you can make it a
linear vector with:

as.vector(combn(df1,3))
#  [1] 1 2 3 1 2 4 1 2 5 1 2 6 1 3 4 1 3 5 1 3 6 1 4 5 1 4 6 1 5 6
[16] 2 3 4 2 3 5 2 3 6 2 4 5 2 4 6 2 5 6 3 4 5 3 4 6 3 5 6 4 5 6

Now you can do the same with the columns of a matrix which carries
the row indices and the column indices:

RC <- cbind(Row=rep(c(1,2,3),2),Col=rep(c(1,2),each=3))
RC
#      Row Col
# [1,]   1   1
# [2,]   2   1
# [3,]   3   1
# [4,]   1   2
# [5,]   2   2
# [6,]   3   2

Now:
df1.3 <- as.vector(combn(df1,3))
ix.RC <- combn((1:nrow(RC)),3)
All   <- cbind(RC[ix.RC,],df1.3)
colnames(All) <- c("Row","Col","Val")
All
#       Row Col   Val
#  [1,]   1   1     1
#  [2,]   2   1     2
#  [3,]   3   1     3
#  [4,]   1   1     1
#  [5,]   2   1     2
#  [6,]   1   2     4
#  [7,]   1   1     1
#  [8,]   2   1     2
#  [9,]   2   2     5
# [10,]   1   1     1
# [11,]   2   1     2
# [12,]   3   2     6
# .................
# [49,]   3   1     3
# [50,]   1   2     4
# [51,]   2   2     5
# [52,]   3   1     3
# [53,]   1   2     4
# [54,]   3   2     6
# [55,]   3   1     3
# [56,]   2   2     5
# [57,]   3   2     6
# [58,]   1   2     4
# [59,]   2   2     5
# [60,]   3   2     6

in which each block of 3 successive rows gives you the 3 Rows,
the 3 Columns, and the 3 Values for one of the 20 possible
choices of 3 cells out of the 6 in the matrix. You could
subsequently rearrange this to suit your purposes.

Ted.

--------------------------------------------------------------------
E-Mail: (Ted Harding) <ted.harding at wlandres.net>
Fax-to-email: +44 (0)870 094 0861
Date: 22-Dec-10                                       Time: 22:39:03
------------------------------ XFMail ------------------------------

```