¿Se puede utilizar la función lapply () para modificar el valor de la entrada?

Question

Me preguntaba si es posible utilizar la función de lapply () para alterar el valor de la entrada, similar a:

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

Estoy buscando algo parecido a un bucle for (), pero utilizando la infraestructura lapply (). No he podido conseguir rapply () para hacer esto.

La razón es que el "verdadero" a2 función es una función difícil que sólo necesita ser evaluado si el valor de A1 [i-1]: cumple con algunos criterios.

refraseo: por lo que estoy tratando de reemplazar el de () en el código de abajo por un lapply () - Tipo cosa:

    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))

La lista de correo R ha aconsejado mirando a la función Reducir () .... como en:

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

que da el mismo resultado que cumprod (a1) ... pero es incluso más lento que el bucle:

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 
> 

¿Alguna idea?

Answer 1

Editar: A raíz de su aclaración: no, no creo que se puede utilizar una función de aplicar de forma recursiva para hacer algo así. El punto de una función de aplicación es que se aplica a través del vector / matriz al mismo tiempo.

También puede vistazo a esta pregunta relacionada en stackoverflow .

Mi vieja respuesta:

Prueba esto:

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))

A diferencia de un bucle for, que necesita para pasar de una referencia a todo lo que necesita dentro de un lapply. El retorno es también una lista, por lo que necesita para emitir de nuevo en cualquier forma que desee.

También es posible que desee ver en el paquete plyr formas fáciles de hacer este tipo de cosas.

Más allá de eso, usted puede hacer su operación sin un bucle:

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

En otras palabras, estas declaraciones son completamente equivalentes:

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

Sin embargo, la primera versión es preferible ya que no tiene iteraciones.