Her R Yeni kullanıcı için bunu söylemek için kullanılır "apply vectorized, kontrol Patrick Burns R Inferno Daire 4 değil" diyor (alıntı):

Bu işlevi kullanmak için bir ortak refleks aile uygulayın.Bu değil vektörleştirme, loop-saklanıyor. Geçerli işlev için bir döngü vardır içinde onun tanımı. Lapply işlevi döngü, ancak yürütme gömer kez döngü için açık bir kabaca eşit olma eğilimindedir.

Nitekim apply kaynak kodu hızlı bir göz döngü ortaya çıkarır:

grep("for", capture.output(getAnywhere("apply")), value = TRUE)
## [1] "        for (i in 1L:d2) {"  "    else for (i in 1L:d2) {"

Tamam şimdiye kadar, ama lapply vapply bir göz aslında tamamen farklı bir resim ortaya koymaktadır:

lapply
## function (X, FUN, ...) 
## {
##     FUN <- match.fun(FUN)
##     if (!is.vector(X) || is.object(X)) 
##        X <- as.list(X)
##     .Internal(lapply(X, FUN))
## }
## <bytecode: 0x000000000284b618>
## <environment: namespace:base>

Yani görünen o ki, R for döngü yok saklanmak yok, daha ziyade iç C yazılı fonksiyon çağırıyorlar.

rabbit hole Bu hızlı bir bakış hemen hemen aynı resim ortaya koymaktadır

Ayrıca, izin asla vectorised olmamak suçlandı örneğin colMeans görevini üstlenecek,

colMeans
# function (x, na.rm = FALSE, dims = 1L) 
# {
#   if (is.data.frame(x)) 
#     x <- as.matrix(x)
#   if (!is.array(x) || length(dn <- dim(x)) < 2L) 
#     stop("'x' must be an array of at least two dimensions")
#   if (dims < 1L || dims > length(dn) - 1L) 
#     stop("invalid 'dims'")
#   n <- prod(dn[1L:dims])
#   dn <- dn[-(1L:dims)]
#   z <- if (is.complex(x)) 
#     .Internal(colMeans(Re(x), n, prod(dn), na.rm))   (0 1i) * 
#     .Internal(colMeans(Im(x), n, prod(dn), na.rm))
#   else .Internal(colMeans(x, n, prod(dn), na.rm))
#   if (length(dn) > 1L) {
#     dim(z) <- dn
#     dimnames(z) <- dimnames(x)[-(1L:dims)]
#   }
#   else names(z) <- dimnames(x)[[dims   1]]
#   z
# }
# <bytecode: 0x0000000008f89d20>
#   <environment: namespace:base>

Değil mi? Ayrıca sadece de rabbit hole bulabiliriz .Internal(colMeans(... çağırır. Nasıl .Internal(lapply(.. Bu farklı mı?

Aslında hızlı bir karşılaştırma sapply kötü colMeans daha ve çok daha büyük bir veri kümesi için for bir döngü daha gerçekleştirdiği ortaya koymaktadır

m <- as.data.frame(matrix(1:1e7, ncol = 1e5))
system.time(colMeans(m))
# user  system elapsed 
# 1.69    0.03    1.73 
system.time(sapply(m, mean))
# user  system elapsed 
# 1.50    0.03    1.60 
system.time(apply(m, 2, mean))
# user  system elapsed 
# 3.84    0.03    3.90 
system.time(for(i in 1:ncol(m)) mean(m[, i]))
# user  system elapsed 
# 13.78    0.01   13.93 

Diğer bir deyişle, söylemek lapply vapply doğru muaslında vectorisedve Patrick Burns gerçekten demek mi? (de lapply aramalar for bir döngü olan apply göre)

Bana, vectorisation öncelikle kod yazmak için daha kolay ve anlamak daha kolay hale getirmektir.

Vectorised bir işlevi amacı, defter tutma for döngüsü ile ilişkili ortadan kaldırmaktır. Örneğin, yerine:

means <- numeric(length(mtcars))
for (i in seq_along(mtcars)) {
  means[i] <- mean(mtcars[[i]])
}
sds <- numeric(length(mtcars))
for (i in seq_along(mtcars)) {
  sds[i] <- sd(mtcars[[i]])
}

Yazabilirsiniz:

means <- vapply(mtcars, mean, numeric(1))
sds   <- vapply(mtcars, sd, numeric(1))

Bu daha kolay aynı (giriş verileri) olanı ve farklı olanı görmek (başvurduğunu işlevi) yapar.

Vectorisation ikincil bir avantajı için-döngü genellikle C ile yazılmış, R. ziyade Bu önemli performans avantajları vardır, ama vectorisation önemli özelliği olduğunu sanmıyorum. Vectorisation temelde beynin kaydetme hakkında, bilgisayar iş tasarrufu değil.