I have a matrix (32X48).

How can I convert the matrix into a single dimensional array?

0 votes

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)
```

0 votes

You can use Joshua's solution but I think you need `Elts_int <- as.matrix(tmp_int)`

Or for loops:

```
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 is a 1d vector.

0 votes

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. The solutions posted so far are so gross I'm not even going to try them...

```
> 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
```

0 votes

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
```

0 votes

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
```

0 votes

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

0 votes

If you instead had a data.frame (df) that had multiple columns and you want to vectorize you can do

as.matrix(df, ncol=1)

0 votes

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()`

.

...