Functions Used data-is the input vector which becomes the data elements of the matrix. nrow-is the numbers of rows to be created. ncol-is the numbers of columns to be created. byrow-is a logical clue,if it is true then input vector elements are arranged by row.
It can also be seen as a collection of 1D arrays. It is also known as the Matrix. Its dimension can be increased from 2 to 3 and 4 so on. They all are referred to as a multi-dimension array.
Conversion of a Matrix into a Row Vector. This conversion can be done using reshape() function along with the Transpose operation. This reshape() function is used to reshape the specified matrix using the given size vector.
Either read it in with 'scan', or just do as.vector() on the matrix. You might want to transpose the matrix first if you want it by rows or columns.
> 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
try 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
If we're talking about data.frame, then you should ask yourself are the variables of the same type? If that's the case, you can use rapply, or unlist, since data.frames are lists, deep down in their souls...
data(mtcars)
unlist(mtcars)
rapply(mtcars, c) # completely stupid and pointless, and slower
array(A)
or array(t(A))
will give you a 1-d array.
From ?matrix
: "A matrix is the special case of a two-dimensional 'array'." You can simply change the dimensions of the matrix/array.
Elts_int <- as.matrix(tmp_int) # read.table returns a data.frame as Brandon noted
dim(Elts_int) <- (maxrow_int*maxcol_int,1)
you can use as.vector()
. It looks like it is the fastest method according to my little benchmark, as follows:
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)
The first solution uses as.vector()
, the second uses the fact that a matrix is stored as a contiguous array in memory and length(m)
gives the number of elements in a matrix m
. The third instantiates an array
from x
, and the fourth uses the concatenate function c()
. I also tried unmatrix
from gdata
, but it's too slow to be mentioned here.
Here are some of the numerical results I obtained:
> 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
Flattening a matrix is a common operation in Machine Learning, where a matrix can represent the parameters to learn but one uses an optimization algorithm from a generic library which expects a vector of parameters. So it is common to transform the matrix (or matrices) into such a vector. It's the case with the standard R function optim()
.
It might be so late, anyway here is my way in converting Matrix to vector:
library(gdata)
vector_data<- unmatrix(yourdata,byrow=T))
hope that will help
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With