Então, costumamos dizer a todos os novos usuários do R que " apply
não são vetorizados, confira o Círculo de Inferno Patrick Burns R 4 ", que diz (cito):
Um reflexo comum é usar uma função na família Apply. Isso não é vetorização, é uma ocultação de loop . A função de aplicação possui um loop for em sua definição. A função lapply enterra o loop, mas os tempos de execução tendem a ser aproximadamente iguais a um loop for explícito.
De fato, uma rápida olhada no apply
código fonte revela o loop:
grep("for", capture.output(getAnywhere("apply")), value = TRUE)
## [1] " for (i in 1L:d2) {" " else for (i in 1L:d2) {"
Ok, até agora, mas uma olhada lapply
ou vapply
realmente revela uma imagem completamente diferente:
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>
Então, aparentemente, não há um for
loop R escondido lá, eles estão chamando a função C escrita interna.
Uma rápida olhada na toca do coelho revela praticamente a mesma imagem
Além disso, vamos pegar a colMeans
função, por exemplo, que nunca foi acusada de não ser vetorizada
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>
Hã? Também chama apenas o .Internal(colMeans(...
que também podemos encontrar na toca do coelho . Então, como isso é diferente .Internal(lapply(..
?
Na verdade, um benchmark rápido revela que o sapply
desempenho não é pior colMeans
e muito melhor do que um for
loop para um grande conjunto de dados
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
Em outras palavras, não é correto dizer que lapply
e vapply
são realmente vectorized (em comparação com apply
o que é um for
loop que também chama lapply
) eo que Patrick Burns realmente quer dizer?
*apply
funções chamam repetidamente funções R, o que as torna repetidas. Com relação ao bom desempenho desapply(m, mean)
: Possivelmente o código C dolapply
método expede apenas uma vez e depois chama o método repetidamente?mean.default
é bastante otimizado.