Construct dynamic-sized array in R

I was wondering about what are the ways to construct dynamic-size array in R.

For one example, I want to construct a n-vector but its dimension n is dynamically determined. The following code will work:

> x=NULL  
> n=2;   
> for (i in 1:n) x[i]=i;  
> x  
[1] 1 2  

For another example, I want to construct a n by 2 matrix where the number o开发者_运维问答f rows n is dynamically determined. But I fail even at assigning the first row:

> tmp=c(1,2)  
> x=NULL  
> x[1,]=tmp  
Error in x[1, ] = tmp : incorrect number of subscripts on matrix  
> x[1,:]=tmp   
Error: unexpected ':' in "x[1,:"  

Thanks and regards!

---

I think the answers you are looking for are rbind() and cbind():

> x=NULL  #  could also use x <- c()

> rbind(x, c(1,2))
     [,1] [,2]
[1,]    1    2
> x <- rbind(x, c(1,2))
> x <- rbind(x, c(1,2))  # now extend row-wise
> x
     [,1] [,2]
[1,]    1    2
[2,]    1    2
> x <- cbind(x, c(1,2))  # or column-wise
> x
     [,1] [,2] [,3]
[1,]    1    2    1
[2,]    1    2    2

The strategy of trying to assign to "new indices" on the fly as you attempted can be done in some languages but cannot be done that way in R.

You can also use sparse matrices provided in the Matrix package. They would allow assignments of the form M <- sparseMatrix(i=200, j=50, x=234) resulting in a single value at row 200, column 50 and 0's everywhere else.

 require(Matrix)
 M <- sparseMatrix(i=200, j=50, x=234)
 M[1,1]
#   [1] 0
 M[200, 50]
#   [1] 234

But I think the use of sparse matrices is best reserved for later use after mastering regular matrices.

---

It is possible to dimension the array after we fill it (in a one-dimensional, vector, fashion)
Emulating the 1-dimension snippet of the question, here's the way it can be done with higher dimensions.

> x=c()
> tmp=c(1,2)
> n=6
> for (i in seq(1, by=2, length=n)) x[i:(i+1)] =tmp;
> dim(x) = c(2,n)
> x
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    1    1    1    1    1
[2,]    2    2    2    2    2    2
> 

Rather than using i:(i+1) as index, it may be preferable to use seq(i, length=2) or better yet, seq(i, length=length(tmp)) for a more generic approach, as illustrated below (for a 4 x 7 array example)

> x=c()
> tmp=c(1,2,3,4)
> n=7
> for (i in seq(1, by=length(tmp), length=n))
      x[seq(i, length=length(tmp))] = tmp;
> dim(x) = c(length(tmp),n)
> x
     [,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,]    1    1    1    1    1    1    1
[2,]    2    2    2    2    2    2    2
[3,]    3    3    3    3    3    3    3
[4,]    4    4    4    4    4    4    4
> 

We can also obtain a similar result by re-assigning x with cbind/rbind, as follow.

> tmp=c(1,2)
> n=6
> x=rbind(tmp)
> for (i in 1:n) x=rbind(x, tmp);
> x
    [,1] [,2]
tmp    1    2
tmp    1    2
tmp    1    2
tmp    1    2
tmp    1    2
tmp    1    2
tmp    1    2

Note: one can get rid of the "tmp" names (these are a side effect of the rbind), with
> dimnames(x)=NULL

---

You can rbind it:

tmp = c(1,2) 

x = NULL

rbind(x, tmp)

---

I believe this is an approach you need

arr <- array(1)

arr <- append(arr,3)

arr[1] <- 2

print(arr[1])

(found on rosettacode.org)

---

When I want to dynamically construct an array (matrix), I do it like so:

n <- 500
new.mtrx <- matrix(ncol = 2, nrow = n)

head(new.mtrx)
     [,1] [,2]
[1,]   NA   NA
[2,]   NA   NA
[3,]   NA   NA
[4,]   NA   NA
[5,]   NA   NA
[6,]   NA   NA

Your matrix is now ready to accept vectors.

Assuming you already have a vector, you pass that to the matrix() function. Notice how values are "broken" into the matrix (column wise). This can be changed with byrow argument.

    matrix(letters, ncol = 2)
      [,1] [,2]
 [1,] "a"  "n" 
 [2,] "b"  "o" 
 [3,] "c"  "p" 
 [4,] "d"  "q" 
 [5,] "e"  "r" 
 [6,] "f"  "s" 
 [7,] "g"  "t" 
 [8,] "h"  "u" 
 [9,] "i"  "v" 
[10,] "j"  "w" 
[11,] "k"  "x" 
[12,] "l"  "y" 
[13,] "m"  "z" 

---

n = 5
x = c(1,2) %o% rep(1,n)
x
#      [,1] [,2] [,3] [,4] [,5]
# [1,]    1    1    1    1    1
# [2,]    2    2    2    2    2

x = rep(1,n) %o% c(1,2)
x
#      [,1] [,2]
# [1,]    1    2
# [2,]    1    2
# [3,]    1    2
# [4,]    1    2
# [5,]    1    2