Convertir une matrice en un tableau à 1 dimension

J'ai une matrice (32X48).

Comment puis-je convertir la matrice en un tableau unidimensionnel?

Soit le lire avec 'scan', soit simplement faire as.vector () sur la matrice. Vous voudrez peut-être d'abord transposer la matrice si vous le souhaitez par lignes ou colonnes.

> m=matrix(1:12,3,4)
> m
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12
> as.vector(m)
 [1]  1  2  3  4  5  6  7  8  9 10 11 12
> as.vector(t(m))
 [1]  1  4  7 10  2  5  8 11  3  6  9 12

essayer c()

x = matrix(1:9, ncol = 3)

x
     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

c(x)

[1] 1 2 3 4 5 6 7 8 9

Si nous parlons de data.frame, alors vous devriez vous demander si les variables sont du même type? Si tel est le cas, vous pouvez utiliser rapply, ou unlist, car les data.frames sont des listes, au plus profond de leur âme ...

 data(mtcars)
 unlist(mtcars)
 rapply(mtcars, c) # completely stupid and pointless, and slower

array(A)ou array(t(A))vous donnera un tableau 1-d.

From ?matrix: "Une matrice est le cas particulier d'un 'tableau' bidimensionnel." Vous pouvez simplement changer les dimensions de la matrice / tableau.

Elts_int <- as.matrix(tmp_int)  # read.table returns a data.frame as Brandon noted
dim(Elts_int) <- (maxrow_int*maxcol_int,1)

Il est peut-être si tard, de toute façon, voici ma façon de convertir Matrix en vecteur:

library(gdata)
vector_data<- unmatrix(yourdata,byrow=T))

j'espère que cela aidera

vous pouvez utiliser as.vector(). Il semble que ce soit la méthode la plus rapide selon mon petit benchmark, comme suit:

library(microbenchmark)
x=matrix(runif(1e4),100,100) # generate a 100x100 matrix
microbenchmark(y<-as.vector(x),y<-x[1:length(x)],y<-array(x),y<-c(x),times=1e4)

La première solution utilise as.vector(), la seconde utilise le fait qu'une matrice est stockée sous forme de tableau contigu en mémoire et length(m)donne le nombre d'éléments dans une matrice m. Le troisième instancie un arrayfrom xet le quatrième utilise la fonction de concaténation c(). J'ai aussi essayé unmatrixde gdata, mais c'est trop lent pour être mentionné ici.

Voici quelques-uns des résultats numériques que j'ai obtenus:

> microbenchmark(
        y<-as.vector(x),
        y<-x[1:length(x)],
        y<-array(x),
        y<-c(x),
        times=1e4)

Unit: microseconds
                expr    min      lq     mean  median      uq       max neval
   y <- as.vector(x)  8.251 13.1640 29.02656 14.4865 15.7900 69933.707 10000
 y <- x[1:length(x)] 59.709 70.8865 97.45981 73.5775 77.0910 75042.933 10000
       y <- array(x)  9.940 15.8895 26.24500 17.2330 18.4705  2106.090 10000
           y <- c(x) 22.406 33.8815 47.74805 40.7300 45.5955  1622.115 10000

L'aplatissement d'une matrice est une opération courante en Machine Learning, où une matrice peut représenter les paramètres à apprendre mais on utilise un algorithme d'optimisation d'une bibliothèque générique qui attend un vecteur de paramètres. Il est donc courant de transformer la matrice (ou les matrices) en un tel vecteur. C'est le cas de la fonction R standard optim().

Vous pouvez utiliser la solution de Joshua mais je pense que vous avez besoin Elts_int <- as.matrix(tmp_int)

Ou pour les boucles:

z <- 1 ## Initialize
counter <- 1 ## Initialize
for(y in 1:48) { ## Assuming 48 columns otherwise, swap 48 and 32
for (x in 1:32) {  
z[counter] <- tmp_int[x,y]
counter <- 1 + counter
}
}

z est un vecteur 1d.

Simple et rapide car un tableau 1d est essentiellement un vecteur

vector <- array[1:length(array)]

Si vous aviez à la place un data.frame (df) qui avait plusieurs colonnes et que vous souhaitez vectoriser, vous pouvez le faire

as.matrix (df, ncol = 1)