有效利用载体

Question

I am attempting to copy one vector to another using the following syntax:

data<-NULL
for( i in 1:nrow(line)){
  data=append(data,line[i*4])
}

From what I have seen, the use of append in this way results in a lot of copying of data, which makes R very slow. What is the syntax for copying the 4th element of one array to another, given that the list you are copying from is of a given size?

Answer 1

If you're trying to extract every fourth element from a vector, you could index using seq to grab the correct elements:

data <- letters[seq(4, length(letters), by=4)]
data
# [1] "d" "h" "l" "p" "t" "x"

Growing the vector one at a time as you show in your question will be slow because you will need to keep re-allocating your vector (see the second circle of The R Inferno for details). However, even pre-allocating your vector and constructing it with a for loop will be slow compared to constructing it in a single vectorized indexing operation.

To get a sense of the speed improvements, consider a comparison to the sort of method you've described, except using pre-allocation:

for.prealloc <- function(x) {
  data <- vector(mode="numeric", length = floor(length(x)/4))
  for (i in 1:floor(length(x)/4)) {
    data[i] <- x[i*4]
  }
  data
}
josilber <- function(x) x[seq(4, length(x), by=4)]
r <- rnorm(10000)
all.equal(for.prealloc(r), josilber(r))
# [1] TRUE

library(microbenchmark)
microbenchmark(for.prealloc(r), josilber(r))
# Unit: microseconds
#             expr      min        lq      mean   median      uq      max neval
#  for.prealloc(r) 1846.014 2035.7890 2351.9681 2094.804 2244.56 5283.285   100
#      josilber(r)   95.757   97.4125  125.9877  113.179  138.96  259.606   100

The approach I propose is 20x faster than using for and a pre-allocated vector (and it will be even faster than using append and a non-pre-allocated vector).

Answer 2

Here are three methods with their benchmarks. You can see that preallocating the vector as in the method2 function is quite a bit faster, while the lapply method is middle, and your function is the slowest.

Of course, these are 1D vectors as opposed to arrays of nD, but I would expected the benchmarks would be similar or even more pronounced.

method1 <- function(line) {
  data<-NULL
  for( i in 1:length(line)){
    data=append(data,line[i])
  }
}

method2 <- function(line) {
  data <- vector(mode="numeric", length = length(line))
  for (i in 1:length(line)) {
    data[i] <- line[i]
  }
}

library(microbenchmark)
r <- rnorm(1000)
microbenchmark(method2(r), unit="ms")
#> Unit: milliseconds
#>        expr     min       lq     mean   median       uq     max neval
#>  method2(r) 2.18085 2.279676 2.428731 2.371593 2.500495 5.24888   100
microbenchmark(lapply(r, function(x) { data<-append(data, x) }), unit="ms")
#> Unit: milliseconds
#>                                                    expr      min       lq
#>  lapply(r, function(x) {     data <- append(data, x) }) 3.014673 3.091299
#>      mean   median       uq      max neval
#>  3.287216 3.150052 3.260199 6.036501   100
microbenchmark(method1(r), unit="ms")
#> Unit: milliseconds
#>        expr      min       lq    mean   median       uq      max neval
#>  method1(r) 3.938684 3.978002 5.71831 4.020001 4.280521 98.58584   100

Didn't realize OP wanted only every fourth. Why not just use a data frame or data.table?

d <- data.frame(matrix(rnorm(1000), ncol=1))
microbenchmark(d2 <- d[seq(1,nrow(d), 4),])
#> Unit: microseconds
#>                           expr    min      lq     mean median      uq
#>  d2 <- d[seq(1, nrow(d), 4), ] 64.846 65.9915 73.08007 67.225 73.8225
#>      max neval
#>  220.438   100
library(data.table)
dt <- data.table(d)
microbenchmark(d2 <- dt[seq(1,nrow(d), 4),])
#> Unit: microseconds
#>                            expr     min       lq     mean  median      uq
#>  d2 <- dt[seq(1, nrow(d), 4), ] 298.163 315.2025 324.8793 320.554 330.416
#>      max neval
#>  655.124   100