R: l'application d'une fonction qui renvoie une liste sur plusieurs colonnes d'une trame de données

Question

Je suis en train d'appliquer une fonction qui prend deux entrées à chaque combinaison de cette liste:

> c('EAS_MAF', 'AMR_MAF', 'AFR_MAF', 'EUR_MAF', 'SAS_MAF') 
[1] "EAS_MAF" "AMR_MAF" "AFR_MAF" "EUR_MAF" "SAS_MAF" 

Pour prendre les valeurs dans chaque combinaison de 2 J'utilise la fonction combn:

> list <- combn(c('EAS_MAF', 'AMR_MAF', 'AFR_MAF', 'EUR_MAF', 'SAS_MAF'),2) 
> list 
    [,1]  [,2]  [,3]  [,4]  [,5]  [,6]  [,7]  [,8]  [,9]  [,10]  
[1,] "EAS_MAF" "EAS_MAF" "EAS_MAF" "EAS_MAF" "AMR_MAF" "AMR_MAF" "AMR_MAF" "AFR_MAF" "AFR_MAF" "EUR_MAF" 
[2,] "AMR_MAF" "AFR_MAF" "EUR_MAF" "SAS_MAF" "AFR_MAF" "EUR_MAF" "SAS_MAF" "EUR_MAF" "SAS_MAF" "SAS_MAF" 

la fonction calcule lui-même le nombre de lignes qui répondent à certains critères et retourne une liste:

sharedCalc.func <- function(pop1, pop2, table = variantTable){ 
    S.count = sum(table[pop1]>0 & table[pop2]>0 & 
        table['consequence'] == 'synonymous SNV') 
    NS.count = sum(table[pop1]>0 & table[pop2]>0 & 
        table['consequence'] != 'synonymous SNV') 
    counts <- list("NS" = NS.count, "S" = S.count, "NS/S" = NS.count/S.count) 
    return(counts) 
} 

Voici un exemple de sortie de cette fonction:

> sharedCalc.func('EAS_MAF', 'AMR_MAF') 
$NS 
[1] 59325 

$S 
[1] 43434 

$`NS/S` 
[1] 1.365865 

Pour exécuter cette fonction sur ma liste que je supposais la fonction apply serait le plus approprié. Cependant, cela renvoie une erreur de tableaux non conforme:

> apply(list, 2, sharedCalc.func) 
Error in FUN(newX[, i], ...) : binary operation on non-conformable arrays 

J'ai essayé aussi la fonction outer et a reçu la même erreur:

> outer(list[1,], list[2,], sharedCalc.func) 
Error in FUN(X, Y, ...) : binary operation on non-conformable arrays 

Je ne sais pas pourquoi je reçois l'erreur. Est-ce dû au retour d'une liste de la fonction? J'ai essayé d'utiliser lapply pour retourner une liste mais cela ne fonctionne pas non plus. Ci-dessous le dput de mes données:

> dput(head(variantTable)) 
structure(list(CHROM = c("1", "1", "1", "1", "1", "1"), POS = c(69224L, 
69428L, 69486L, 69487L, 69496L, 69521L), ID = c("rs568964432", 
"rs140739101", "rs548369610", "rs568226429", "rs150690004", "rs553724620" 
), REF = c("A", "T", "C", "G", "G", "T"), ALT = c("T", "G", "T", 
"A", "A", "A"), AF = c(0.000399361, 0.0189696, 0.000199681, 0.000399361, 
0.000998403, 0.000399361), AC = c(2L, 95L, 1L, 2L, 5L, 2L), AN = c(5008L, 
5008L, 5008L, 5008L, 5008L, 5008L), consequence = c("nonsynonymous SNV", 
"nonsynonymous SNV", "synonymous SNV", "nonsynonymous SNV", "nonsynonymous SNV", 
"nonsynonymous SNV"), gene = c("OR4F5", "OR4F5", "OR4F5", "OR4F5", 
"OR4F5", "OR4F5"), refGene_id = c("NM_001005484", "NM_001005484", 
"NM_001005484", "NM_001005484", "NM_001005484", "NM_001005484" 
), AA_change = c("('D', 'V')", "('F', 'C')", "('N', 'N')", "('A', 'T')", 
"('G', 'S')", "('I', 'N')"), X0.fold_count = c(572L, 572L, 572L, 
572L, 572L, 572L), X4.fold_count = c(141L, 141L, 141L, 141L, 
141L, 141L), EAS_MAF = c(0, 0.003, 0.001, 0, 0, 0), AMR_MAF = c(0.0029, 
0.036, 0, 0, 0.0014, 0.0029), AFR_MAF = c(0, 0.0015, 0, 0.0015, 
0.003, 0), EUR_MAF = c(0, 0.0497, 0, 0, 0, 0), SAS_MAF = c(0, 
0.0153, 0, 0, 0, 0), nonAFR_N = c(309227L, 1128036L, 262551L, 
0L, 309227L, 309227L), nonAFR_weighted = c(0.0029, 0.0261704282487438, 
0.001, 0, 0.0014, 0.0029)), .Names = c("CHROM", "POS", "ID", 
"REF", "ALT", "AF", "AC", "AN", "consequence", "gene", "refGene_id", 
"AA_change", "X0.fold_count", "X4.fold_count", "EAS_MAF", "AMR_MAF", 
"AFR_MAF", "EUR_MAF", "SAS_MAF", "nonAFR_N", "nonAFR_weighted" 
), row.names = c(NA, 6L), class = "data.frame") 

Answer 1

les opérations suivantes:

l <- combn(c('EAS_MAF', 'AMR_MAF', 'AFR_MAF', 'EUR_MAF', 'SAS_MAF'),2) 
l 
    [,1]  [,2]  [,3]  [,4]  [,5]  [,6]  
[1,] "EAS_MAF" "EAS_MAF" "EAS_MAF" "EAS_MAF" "AMR_MAF" "AMR_MAF" 
[2,] "AMR_MAF" "AFR_MAF" "EUR_MAF" "SAS_MAF" "AFR_MAF" "EUR_MAF" 
    [,7]  [,8]  [,9]  [,10]  
[1,] "AMR_MAF" "AFR_MAF" "AFR_MAF" "EUR_MAF" 
[2,] "SAS_MAF" "EUR_MAF" "SAS_MAF" "SAS_MAF" 

mapply(sharedCalc.func, l[1,], l[2,]) 
    EAS_MAF EAS_MAF EAS_MAF EAS_MAF AMR_MAF AMR_MAF AMR_MAF AFR_MAF 
NS 1  1  1  1  2  1  1  1  
S 0  0  0  0  0  0  0  0  
NS/S Inf  Inf  Inf  Inf  Inf  Inf  Inf  Inf  
    AFR_MAF EUR_MAF 
NS 1  1  
S 0  0  
NS/S Inf  Inf  

mapply est la version à plusieurs variables de sapply, à utiliser si vous voulez parcourir plusieurs listes en même temps. En remarque: il est presque toujours une mauvaise idée d'écraser la fonctionnalité R intégrée avec vos propres objets. Donc, appeler un objet list est une mauvaise idée, c'est pourquoi je l'ai changé en l dans le code ci-dessus.

---

Pour garder les noms de colonnes, on pourrait faire quelque chose comme ceci:

out <- mapply(sharedCalc.func, l[1,], l[2,]) 
setNames(data.frame(out), mapply(paste, l[1,], l[2,], sep="-")) 
    EAS_MAF-AMR_MAF EAS_MAF-AFR_MAF EAS_MAF-EUR_MAF EAS_MAF-SAS_MAF 
NS     1    1    1    1 
S     0    0    0    0 
NS/S    Inf    Inf    Inf    Inf 
    AMR_MAF-AFR_MAF AMR_MAF-EUR_MAF AMR_MAF-SAS_MAF AFR_MAF-EUR_MAF 
NS     2    1    1    1 
S     0    0    0    0 
NS/S    Inf    Inf    Inf    Inf 
    AFR_MAF-SAS_MAF EUR_MAF-SAS_MAF 
NS     1    1 
S     0    0 
NS/S    Inf    Inf 

Answer 2

Vous essayez de faire R utiliser colonne1 comme entrée, puis passer à colonne2, et ainsi de suite.

inputs <- combn(c('EAS_MAF', 'AMR_MAF', 'AFR_MAF', 'EUR_MAF', 'SAS_MAF'),2) 
output <- Map(sharedCalc.func, inputs[1, ], inputs[2, ]) 

Map prendra la première valeur de inputs[1, ] et inputs[2, ] que les arguments à la première fois sharedCalc.func est appelé et enregistre la sortie dans une liste. Puis passe aux secondes valeurs, etc. jusqu'à ce que toutes les valeurs aient été utilisées. Donc output est maintenant une liste qui contient 10 sous-listes nommées.

Remarque: Il semble que quelque chose ne va pas dans votre fonction, car elle ne produit pas ce qu'elle est supposée produire. La même sortie est produite quand j'appelle sharedCalc.func("EAS_MAF", "AMR_MAF")

output[[1]] 
# $NS 
# [1] 1 
# $S 
# [1] 0 
# $`NS/S` 
# [1] Inf