Comment obtenir toutes les combinaisons de valeurs par ligne dans un dataframe

Je suis d'accord avec la réponse de Maurits Evers, au rang complet, vous obtenez une combinaison binomiale par lignes: n variables signifient 2 ^ n combinaison ... si vous ajoutez m-1 colonnes, cela donne 2 ^ (n + m) possibilités.

Voici une alternative utilisant partitions :: composition .

system.time(p <- compositions(66, 7))
#    user  system elapsed 
#   14.11    1.61   15.72

Le résultat est une liste où chaque élément est une matrice pour chaque ligne des données d'origine. Chaque colonne de matrice est une partition (échantillonnée).

system.time(p <- compositions(66, 6))
#   user  system elapsed 
#   1.53    0.16    1.68 
str(p)
# 'partition' int [1:6, 1:13019909] 66 0 0 0 0 0 65 1 0 0 ...

J'ai essayé de partitionner la plus grande somme de lignes dans vos données d'exemple (66), et cela fonctionne assez rapidement. Ainsi, si vos sommes de lignes ne sont pas beaucoup plus grandes et que le nombre de colonnes est petit (comme ici), le code ci-dessus peut être une option viable.

# [[1]]
#      [,1] [,2] [,3] [,4]
# [1,]    1    0    1    0
# [2,]    1    2    0    0
# [3,]    0    0    1    2
# 
# [[2]]
#     [,1] [,2] [,3] [,4]
# [1,]    1    0    0    2
# [2,]    3    1    0    0
# [3,]    0    3    4    2
# 
# [[3]]
#      [,1] [,2] [,3] [,4]
# [1,]    1    2    1    1
# [2,]    0    0    1    1
# [3,]    1    0    0    0

Notez qu'il 'explose' rapidement si le nombre de colonnes augmente:

library(partitions)

# smaller toy data
d <- data.frame(x1 = c(0, 1, 1), x2 = c(2, 2, 0), x3 = c(0, 1, 1))

# calculate row sums
rs <- rowSums(d)

# for each unique row sum, partition the value with order m = number of columns
# this avoids repeating calculation of partitions on duplicate row sums
l <- lapply(unique(rs), compositions, m = ncol(d))

# name list elements with row sums
names(l) <- unique(rs)

# set number of samples
n <- 4

# to reproduce sample in this example  
set.seed(1)

# loop over rows in data frame
lapply(1:nrow(d), function(i){

  # index list of partitions using row sums
  m <- l[[as.character(rs[i])]]

  # number of columns to sample from
  nc <- ncol(m)

  # select columns from matrix using a sample of n column indexes
  m[ , sample(nc, n, replace = TRUE)]
})

Désolé @Henrik pour la réponse tardive. Votre code a très bien fonctionné pour moi! Cependant, avec l'aide d'un de mes collègues, j'ai trouvé ce code (je vais simplement le montrer en utilisant vos exemples de données):

#data
d <- data.frame(x1 = c(0, 1, 1), x2 = c(2, 2, 0), x3 = c(0, 1, 1))
#Number of replicates I want
replicates <- 1000
#Number of columns in the table 
k<- 3

l <- NULL

#unlist the dataframe
list <- lapply(apply(d,1,list),unlist)

#Calculate replicates of the dataframe, where numbers are permuted within rows

permutations <- lapply(seq(replicates), function(j){
        l_sampled <- lapply(list, function(x){
          pos.random <- sample(k, sum(x), replace = T) 
          x.random <- rep(0,k)                        
          for (i in 1:k){
            x.random[i] <- sum(pos.random==i)
          }
          l = rbind(l, data.frame(x.random)) 
        })
        df <- data.frame(matrix(unlist(l_sampled), nrow=length(l_sampled), byrow=T))
})

#Example for results:

> permutations[[8]]
  X1 X2 X3
1  2  0  0
2  1  2  1
3  1  0  1
> permutations[[10]]
  X1 X2 X3
1  0  1  1
2  2  0  2
3  0  2  0