Você pode usar a função Lapply () para alterar o valor da entrada?

Question

Eu queria saber se é possível usar a função Lapply () para alterar o valor da entrada, semelhante a:

a1<-runif(100)
a2<-function(i){
a1[i]<-a1[i-1]*a1[i];a1[i]
}
a3<-lapply(2:100,a2)

Estou procurando algo semelhante a um loop para (), mas usando a infraestrutura Lapply (). Não consegui fazer com que o Rapply () faça isso.

A razão é que a função A2 "real" é uma função difícil que só precisa ser avaliada se o valor de A1 [i-1] atender a alguns critérios.

Re-phraseing: Então, estou tentando substituir o para () no código abaixo por uma coisa de tipo Lapply ():

    a1<-runif(100)
    a2<-function(i, a1){
        a1[i]<-a1[i-1]*2
        a1[i]
    }
    a3<-as.numeric(lapply(2:100, a2, a1=a1))
#compare the output of a3 with that of a1 after the recursive loop
    a2<-a1 #saved for comparison
    for(i in 2:length(a1)){
        a1[i]<-a1[i-1]*2
    }
cbind(a1[2:100],a3)
#actually this is would be like writting a lapply() version of the cumprod() function
cbind(a1,cumprod(a2))

A lista de discussão R aconselhou procurar a função Reduce () .... como em:

a1<-runif(100)
cadd<-function(x) Reduce("*", x, accumulate = TRUE)
cadd(a1)

que dá o mesmo resultado que Cumprod (A1) ... mas é ainda mais lento que o loop:

a1<-runif(100000)
cadd<-function(x) Reduce("*", x, accumulate = TRUE)
looop<-function(a1){
j<-length(a1)
    for(i in 2:j){
        a1[i]<-a1[i-1]*a1[i]
    }
a1
}

> system.time(cadd(a1))
   user  system elapsed 
  1.344   0.004   1.353 
> system.time(cumprod(a1))
   user  system elapsed 
  0.004   0.000   0.002 
> system.time(loop(a1))
   user  system elapsed 
  0.772   0.000   0.775 
> 

Qualquer ideia ?

Answer 1

Editar: Seguindo seu esclarecimento: Não, não acredito que você possa usar uma função Aplicar para fazer algo recursivamente assim. O ponto principal de uma função de aplicação é que ela se aplica ao longo do vetor/matriz ao mesmo tempo.

Você também pode querer Veja esta pergunta relacionada no StackOverflow.

Minha resposta antiga:

Experimente isso:

a1<-runif(100)
a2<-function(i, a1){
    a1[i]<-a1[i-1]*a1[i]
    a1[i]
}
a3 <- as.numeric(lapply(2:100, a2, a1=a1))

Ao contrário de um for Loop, você precisa passar em uma referência a qualquer coisa que você precise dentro de um lapply. O retorno também é uma lista, então você precisa lançá -lo de volta na forma que desejar.

Você também pode querer olhar para o pacote Plyr para obter maneiras fáceis de fazer esse tipo de coisa.

Além disso, você pode fazer sua operação sem um loop:

a3 <- a1[-length(a1)] * a1[-1]

Em outras palavras, essas declarações são completamente equivalentes:

> all((a1[-length(a1)] * a1[-1]) == as.numeric(lapply(2:100, a2, a1=a1)))
[1] TRUE

Mas a primeira versão é preferível, pois não possui iterações.