Comment puis-je faire une matrice à partir d'une liste de vecteurs dans R?

Objectif: à partir d'une liste de vecteurs de même longueur, de créer une matrice où chaque vecteur devient une ligne.

Exemple:

> a <- list()
> for (i in 1:10) a[[i]] <- c(i,1:5)
> a
[[1]]
[1] 1 1 2 3 4 5

[[2]]
[1] 2 1 2 3 4 5

[[3]]
[1] 3 1 2 3 4 5

[[4]]
[1] 4 1 2 3 4 5

[[5]]
[1] 5 1 2 3 4 5

[[6]]
[1] 6 1 2 3 4 5

[[7]]
[1] 7 1 2 3 4 5

[[8]]
[1] 8 1 2 3 4 5

[[9]]
[1] 9 1 2 3 4 5

[[10]]
[1] 10  1  2  3  4  5

Je veux:

      [,1] [,2] [,3] [,4] [,5] [,6]
 [1,]    1    1    2    3    4    5
 [2,]    2    1    2    3    4    5
 [3,]    3    1    2    3    4    5
 [4,]    4    1    2    3    4    5
 [5,]    5    1    2    3    4    5
 [6,]    6    1    2    3    4    5
 [7,]    7    1    2    3    4    5
 [8,]    8    1    2    3    4    5
 [9,]    9    1    2    3    4    5
[10,]   10    1    2    3    4    5
InformationsquelleAutor Christopher DuBois | 2009-08-25
  1. 119

    Une option est d'utiliser do.call(): 

     > do.call(rbind, a)
      [,1] [,2] [,3] [,4] [,5] [,6]
 [1,]    1    1    2    3    4    5
 [2,]    2    1    2    3    4    5
 [3,]    3    1    2    3    4    5
 [4,]    4    1    2    3    4    5
 [5,]    5    1    2    3    4    5
 [6,]    6    1    2    3    4    5
 [7,]    7    1    2    3    4    5
 [8,]    8    1    2    3    4    5
 [9,]    9    1    2    3    4    5
[10,]   10    1    2    3    4    5
    • Donc, la différence entre la ce et la norme rbind (), c'est que ne.call() passe à chaque élément de la liste en tant que distincte de l'arg - est-ce que le droit? n'.appel(rbind,a) est équivalent à rbind(a[[1]], un[[2]]... un[[10]])?
    • Autant que je sache, oui.
    • n'.call() est idéal pour cet effet, je voudrais qu'il soit mieux "documenté" dans le matériel de présentation.
    InformationsquelleAutor Christopher DuBois
  2. 14

    simplify2array est une fonction de base qui est assez intuitif. Cependant, puisque R est la valeur par défaut est de remplir les données par colonnes d'abord, vous aurez besoin de transposer la sortie. (sapply utilise simplify2array, comme documenté dans help(sapply).)

    > t(simplify2array(a))
      [,1] [,2] [,3] [,4] [,5] [,6]
 [1,]    1    1    2    3    4    5
 [2,]    2    1    2    3    4    5
 [3,]    3    1    2    3    4    5
 [4,]    4    1    2    3    4    5
 [5,]    5    1    2    3    4    5
 [6,]    6    1    2    3    4    5
 [7,]    7    1    2    3    4    5
 [8,]    8    1    2    3    4    5
 [9,]    9    1    2    3    4    5
[10,]   10    1    2    3    4    5
    InformationsquelleAutor Kalin
  3. 11

    Pas simple, mais il fonctionne:

    > t(sapply(a, unlist))
      [,1] [,2] [,3] [,4] [,5] [,6]
 [1,]    1    1    2    3    4    5
 [2,]    2    1    2    3    4    5
 [3,]    3    1    2    3    4    5
 [4,]    4    1    2    3    4    5
 [5,]    5    1    2    3    4    5
 [6,]    6    1    2    3    4    5
 [7,]    7    1    2    3    4    5
 [8,]    8    1    2    3    4    5
 [9,]    9    1    2    3    4    5
[10,]   10    1    2    3    4    5
    • Noter que cela ne fonctionne pas pour l'inégalité de longueur des vecteurs.
    • Avec rjson résultats, colMeans fonctionne uniquement pour cette méthode! Merci!!!!
    InformationsquelleAutor Paolo
  4. 9

    Le haut- matrix fonction a la bonne option à saisir des données byrow. Combinez cela avec un unlist sur votre liste source vous donnera une matrice. Nous avons également besoin de spécifier le nombre de lignes de sorte qu'il peut casser la non cotées de données. Qui est:

    > matrix(unlist(a), byrow=TRUE, nrow=length(a) )
      [,1] [,2] [,3] [,4] [,5] [,6]
 [1,]    1    1    2    3    4    5
 [2,]    2    1    2    3    4    5
 [3,]    3    1    2    3    4    5
 [4,]    4    1    2    3    4    5
 [5,]    5    1    2    3    4    5
 [6,]    6    1    2    3    4    5
 [7,]    7    1    2    3    4    5
 [8,]    8    1    2    3    4    5
 [9,]    9    1    2    3    4    5
[10,]   10    1    2    3    4    5
    • Ou de remplir une matrice par des colonnes, puis de transposer: t( matrix( unlist(a), ncol=length(a) ) ).
    InformationsquelleAutor Kalin
  5. 7
    t(sapply(a, '[', 1:max(sapply(a, length))))

    où 'a' est une liste de.
    Serait travailler pour l'inégalité de la taille de ligne

    InformationsquelleAutor Arihant
  6. 3
    > library(plyr)
> as.matrix(ldply(a))
      V1 V2 V3 V4 V5 V6
 [1,]  1  1  2  3  4  5
 [2,]  2  1  2  3  4  5
 [3,]  3  1  2  3  4  5
 [4,]  4  1  2  3  4  5
 [5,]  5  1  2  3  4  5
 [6,]  6  1  2  3  4  5
 [7,]  7  1  2  3  4  5
 [8,]  8  1  2  3  4  5
 [9,]  9  1  2  3  4  5
[10,] 10  1  2  3  4  5
    • Ce sera tout simplement ne pas fonctionner si les lignes n'ont pas la même longueur, alors que faire.appel(rbind,...) fonctionne toujours.
    • des indices pour le faire fonctionner pour l'inégalité de la taille de ligne avec NA pour la ligne manquante de données?
    • En fait, faire.appel(rbind,...) ne fonctionne pas pour l'inégalité de longueur des vecteurs, à moins que vous vraiment l'intention d'avoir le vecteur réutilisés lors du remplissage de la ligne à la fin. Voir Arihant la réponse d'une manière qui se remplit avec NA valeurs à la fin à la place.
    InformationsquelleAutor learnr