Buenas días a todos, una vez más os escribo para preguntaros una duda. Estoy haciendo bucles con data frames, el problema es que al hacer bucles de esta manera el sistema se relentiza. He buscado por internet y en varias web te dicen que evites los bucles en la medida de lo posible y que intentes funcionar con c++ con la librería Rccp http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. Mi preguta es 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje 2 Alguna página con ejemplitos fáciles de Rccp. Como ya veis tengo la duda a medio madurar, pero si me podeis dar un empujón os lo agradeceré. Un saludo y gracias por adelantado. [[alternative HTML version deleted]]
Hola, ¿Qué quieres hacer en y con el data.frame? R está orientado a data.frames y listas. La mayor parte de las librerías y sus funciones tratan sobre data.frames o equivalentes. Dependiendo de lo que quieras hacer te podemos recomendar una u otra. Así de forma librerías de propósito general has mirado: data.table, sqldf, plyr.... Muy probablemente incluso dependiendo de lo que necesites con las funciones que aporta el paquete "base" podría ser suficiente. Saludos, Carlos Ortega www.qualityexcellence.es Hay varias funciones para calcular cosas sobre data.frames e igualmente librerías específicas que aportan funciones específicas para procesar data.frames El 12 de junio de 2012 14:32, Javier Villacampa González < javier.villacampa.gonzalez@gmail.com> escribió:> Buenas días a todos, > > una vez más os escribo para preguntaros una duda. Estoy haciendo bucles con > data frames, el problema es que al hacer bucles de esta manera el sistema > se relentiza. He buscado por internet y en varias web te dicen que evites > los bucles en la medida de lo posible y que intentes funcionar con c++ con > la librería Rccp http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. > > Mi preguta es > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje > 2 Alguna página con ejemplitos fáciles de Rccp. > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar un > empujón os lo agradeceré. > > Un saludo y gracias por adelantado. > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >-- Saludos, Carlos Ortega www.qualityexcellence.es [[alternative HTML version deleted]]
Hola Javier, ¿es necesario que hagas bucles? Quizá se pueda vectorizar la operación. ¿Podrías mostrarnos el código que estas usando? Luciano El 12 de junio de 2012 09:32, Javier Villacampa González < javier.villacampa.gonzalez@gmail.com> escribió:> Buenas días a todos, > > una vez más os escribo para preguntaros una duda. Estoy haciendo bucles con > data frames, el problema es que al hacer bucles de esta manera el sistema > se relentiza. He buscado por internet y en varias web te dicen que evites > los bucles en la medida de lo posible y que intentes funcionar con c++ con > la librería Rccp http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. > > Mi preguta es > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje > 2 Alguna página con ejemplitos fáciles de Rccp. > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar un > empujón os lo agradeceré. > > Un saludo y gracias por adelantado. > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >[[alternative HTML version deleted]]
Las funciones apply, lapply, sapply, tapply son tus amigas... También es bastante posible que estés haciendo tareas con bucles que se pueden escribir con instrucciones matriciales y subíndices. Del tipo: x[x[>3]]<-3 en lugar de: for(i in 1:length(x)){ if x[i]>3 then x[i]<-3 } Mi recomendacion es que antes de seguir programando te recorras los ejemplos de dos o tres manuales diferentes que suelen tener ejemplos de como aprovechar estas instrucciones en R (Los que puedes encontrar en CRAN deberían servirte). Merece la pena invertir algo de tiempo en aprender a sacarles partido. El 12 de junio de 2012 14:32, Javier Villacampa González < javier.villacampa.gonzalez@gmail.com> escribió:> Buenas días a todos, > > una vez más os escribo para preguntaros una duda. Estoy haciendo bucles con > data frames, el problema es que al hacer bucles de esta manera el sistema > se relentiza. He buscado por internet y en varias web te dicen que evites > los bucles en la medida de lo posible y que intentes funcionar con c++ con > la librería Rccp http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. > > Mi preguta es > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje > 2 Alguna página con ejemplitos fáciles de Rccp. > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar un > empujón os lo agradeceré. > > Un saludo y gracias por adelantado. > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >[[alternative HTML version deleted]]
Estimado González Si. Compilando. Yo realicé una prueba muy sencilla es es mucho más veloz, claro, esta posibilidad existe en la última versión de R. Javier Marcuzzi -----Mensaje original----- From: Javier Villacampa González Sent: Tuesday, June 12, 2012 9:32 AM To: r-help-es en r-project.org Subject: [R-es] help: Bucles rápidos en R Buenas días a todos, una vez más os escribo para preguntaros una duda. Estoy haciendo bucles con data frames, el problema es que al hacer bucles de esta manera el sistema se relentiza. He buscado por internet y en varias web te dicen que evites los bucles en la medida de lo posible y que intentes funcionar con c++ con la librería Rccp http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. Mi preguta es 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje 2 Alguna página con ejemplitos fáciles de Rccp. Como ya veis tengo la duda a medio madurar, pero si me podeis dar un empujón os lo agradeceré. Un saludo y gracias por adelantado. [[alternative HTML version deleted]] _______________________________________________ R-help-es mailing list R-help-es en r-project.org https://stat.ethz.ch/mailman/listinfo/r-help-es
Lo primero gracias a todos, Una de los problemas que me encontré fue al hacer modelos sociales para un máster que estoy haciendo, aunque esta duda me surge habitualmente en mi trabajo. La verdad es que por comodidad intento evitar vectorizar las operaciones ya que a mi parecer hace incomodo el proceso de lectura, sobretodo una vez pasados un par de meses. Ahora al lio, esto he sido incapaz de vectorizarlo y creo que lo voy a intentar con c++... Estoy modelizando el modelo social Axelrof # Info extra # Artículo # http://www-personal.umich.edu/~axe/research/Dissemination.pdf # Tendría que quedar algo así # http://ifisc.uib.es/research/APPLET_Axelrod/Culture.html #------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 1 Genero una matriz de datos nxn que representan individuos con unas características, la conjunción de dichas características le da un color, los individuos están distribuidos como un tablero de ajedrez en el plano. (Empieza el bucle. Este bucle se puede ver al final de este documento. Buscar require(animation) con control +F si se quiere llegar al bucle de manera rápida al bucle) 2 Elijo un individuo al azar que interactua con uno de sus cuatro vecinos este, oeste, norte o sur, la probabilidad de interactuar depende de el número de características comunes que tenga con el resto a más parecido más probable a menos menos. 3 Se cambia una caracterítstica y se sigue el proceso. A poder ser 80.000 veces (imposible con mi máquina pasar de 8.000) (Fin del bucle) Os mando el bucle por si lo quereis correr. Pero la cosa no es que nadie me lo haga, es una cosa personal entre mi máquina y yo. De todas manera es demasiado código para leer, por eso no lo he mandado de primeras. #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- rm(list=ls()) #Parametros L<- 15 #Tamaño del grupo N=L*L N<-L*L #Sample size Fc<-2 #Number of commponents q<-3 #Number of commponent values p<-0.05 #Probability of remote conexion traits<-letters[1:q] #Numeric values is not a good idea for this exercise I prefer do with letters #---------------------------------------------------------- #Matriz de valores culturales M1<-matrix(NA, ncol=Fc+1, nrow=N) i<-1 for(i in 1:N){#Create vectors M1[i,-(Fc+1)]<- sample(traits, Fc, replace=T) M1[i,(Fc+1)]<- paste( M1[i,1:Fc], sep="", collapse="") } M2<-matrix(NA, nrow=N, ncol=2) M2[,2]<-rep(1:L,L) #unidades for(i in 1:L){ M2[(1+(i-1)*L):(L+(i-1)*L),1]<-rep(i,L) #Decenas de las coordenas } M<-cbind(M2,M1) #head(M) #---------------------------------------------------------- #Creamos los factores que definiran los colores colores<-rainbow(q^Fc) combn(x=traits,m=Fc)#Combina valores no nos vale combn(letters[1:4], 2, simplify=F) require(utils) lista<-NULL for(i in 1:Fc){ lista[[i]]<-traits #create a list for function expand.grid } factores<-interaction(lista,sep="") cbind(factores, colores) factores1<-levels(factores) #----------------------------------------------------------- #Creamos ahora el factor en la matriz de datos datos<-as.data.frame(M, stringsAsFactors=F) names(datos)[c(1,2)]<-c("x","y") names(datos)[2+Fc+1]<-c("factor") datos$factor<- factor(datos$factor, levels=factores1) datos[,c(1)]<-as.numeric(datos[,c(1)]) datos[,c(2)]<-as.numeric(datos[,c(2)]) head(datos) summary(datos) #-------------------------------------------------------------------------- #We calculate th interaction matrix #We can alocate the file and colum by row name with this algorithm # file %% L = y coordenade if is equal to zero we must plus one and # x coordenade is file %/% L = x coordenade # in other case file %/% L = x coordenade -1 #On other hand if we are in the border we only have 3 or 2 neighbours #Two if the point is a corner and 3 in other case. interac<-matrix(0,nrow=N,ncol=N) coordenades<-NULL coordenades<-as.data.frame(matrix(0,nrow=N, ncol=3)) names(coordenades)<-c("x","y","file") for ( i in 1:N){ if(i %% L!= 0){ coordenades[i,]$y<-i %% L coordenades[i,]$x<- i%/% L +1 }else{ coordenades[i,]$y<- L coordenades[i,]$x<- i%/% L } coordenades[i,]$file<-i } head(coordenades) #coordenades #Now we compute standard interacction matrix i<-1 for(i in 1:(N)){#central map values x<-coordenades[coordenades$file==i,]$x y<-coordenades[coordenades$file==i,]$y interac[i,coordenades[coordenades$x==(x+1) & coordenades$y==(y),]$file]<-1 interac[i,coordenades[coordenades$x==(x-1) & coordenades$y==(y),]$file]<-1 interac[i,coordenades[coordenades$x==(x) & coordenades$y==(y+1),]$file]<-1 interac[i,coordenades[coordenades$x==(x) & coordenades$y==(y-1),]$file]<-1 } #------------------------------------------------------------------------- plot(datos[,c(1,2)], col=colores[datos$factor],pch=15, cex=2 ,las=1, xlim=c(1,L), ylim=c(0.5,L+0.5)) title("n=0" ) rm(M,M1,M2,i,lista) #Variable names #factores1 contain al factor names #datos contain x and y coordenades trait of F dimensions(features) and the factor value #coordenades keep the relation between x and y coordenade and corresponde with data file number #interac all interacctions between elemets #colores all color pallet #L Tamaño del grupo N=L*L #N Sample size # Fc Number of commponents #q Number of commponent values #p Probability of remote conexion #traits Numeric values is not a good idea for this exercise I prefer do with letters #---------------------------------------------------------- head(datos) total<-8000 #datos11<-datps setwd("C:/Documents and Settings/UIB/Mis documentos/Dropbox/Máster/Física") #install.packages("animation") require(animation) ## A quick and dirty demo saveHTML({ #---------------------------------------------------------------------------------------------------------------------------- #Loop for Start html file for(k in 1:total){ aleatorio<-sample(1:N,1) #Selects one random element #aleatorio<-1 selected<-datos[aleatorio,] #Selected file neighboursIndex<-row(as.matrix(interac[aleatorio,]))[interac[aleatorio, ]==1] #Selects neighbours of our random element neighbours<-datos[neighboursIndex,] neighbours comunMeasure<-matrix(0, nrow=dim(neighbours)[1], ncol=dim(neighbours)[2]-3) #measures the comum values for(i in 3:(Fc+2)){ NumberN<-dim(neighbours)[1] #the number of neighbours measure for(j in 1:NumberN){ if( selected[,i]==neighbours[j,i]){ comunMeasure[j,i-2]<-1 #When is a neighbour } } } if(sum(apply(comunMeasure,1, sum))!=0){ ProbVect<-apply(comunMeasure,1, sum)/sum(apply(comunMeasure,1, sum)) selectedIndex<-sample(1:dim(neighbours)[1],prob=ProbVect, size=1 ) #Densitiy interaction function if is most similar is most probable of interact similar<- neighbours[selectedIndex,] #Select the most similar neighbour and we choose a different feature if any for change. if(sum(comunMeasure[selectedIndex,])!=Fc){ #Change different feature respect original or selected value change<-sample(row(as.matrix(comunMeasure[selectedIndex,]))[comunMeasure[selectedIndex, ]!=1],1) change<-change+2 similar[change]<-selected[change] similar$factor<-paste( similar[3:(Fc+2)], sep="", collapse="") similar } datos[rownames(similar),]<-similar datos[rownames(similar),] }else{ #No do anything } #plot(datos1[,c(1,2)], col=colores[datos1$factor],pch=15, cex=2 ,las=1, xlim=c(1,L), ylim=c(0.5,L+0.5)) plot(datos[,c(1,2)], col=colores[datos$factor],pch=15, cex=2 ,las=1, xlim=c(1,L), ylim=c(0.5,L+0.5)) title(paste("n=",k,sep="" )) print(paste(k ," de ",total, sep="")) } #finish loop for html file #---------------------------------------------------------------------------------------------------------------------------- }, img.name = "Axel", imgdir = "A50011", htmlfile "Axel1000.html",modelautobrowse = T, title = "Axelrof ", description = F , outdir=getwd()) El 12 de junio de 2012 14:32, Javier Villacampa González < javier.villacampa.gonzalez@gmail.com> escribió:> Buenas días a todos, > > una vez más os escribo para preguntaros una duda. Estoy haciendo bucles > con data frames, el problema es que al hacer bucles de esta manera el > sistema se relentiza. He buscado por internet y en varias web te dicen que > evites los bucles en la medida de lo posible y que intentes funcionar con > c++ con la librería Rccp > http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. > > Mi preguta es > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje > 2 Alguna página con ejemplitos fáciles de Rccp. > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar un > empujón os lo agradeceré. > > Un saludo y gracias por adelantado. >[[alternative HTML version deleted]]
Perdonad el mail anterior, mandé por error sin revisar la redacción, grave error.... Lo primero gracias a todos, Una de los problemas que me he encontrado ha sido este: no voy a engañar a nadie es un trabajo de modelos sociales para un máster que estoy haciendo, aunque este tipo de dudas tambien me surge habitualmente en mi trabajo. La verdad es que por comodidad intento evitar vectorizar las operaciones. A mi parecer vectorizar hace incomodo el proceso de lectura, sobretodo una vez pasados un par de meses. Ahora vamos al lio. Esto he sido incapaz de vectorizarlo y creo que lo voy a intentar con c++... Estoy modelizando el modelo social Axelrof # Info extra # Artículo # http://www-personal.umich.edu/~axe/research/Dissemination.pdf # Tendría que quedar algo así # http://ifisc.uib.es/research/APPLET_Axelrod/Culture.html #------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 1 Genero una matriz de datos nxn que representan individuos con unas características que pueden tomar n valores, la conjunción de dichas características le da un color, los individuos están distribuidos como un tablero de ajedrez en el plano. Un ejemplo de dos individuo serían coordenada x =1 coordenada y =1 características religión = católica ideología = acrata gusto por los helados = fresa coordenada x =1 coordenada y =2 características religión = musulmana ideología = liberal gusto por los helados = fresa Estos dos individuos tienen en común su pasión por los helados de fresa y cada uno tiene un color dado por la combinacion de sus características, si todas sus carácterísticas son iguales tienen el mismo color cuando los dibujo. (Empieza el bucle. Este bucle se puede ver al final de este documento. Buscar require(animation) con control +F si se quiere llegar al bucle de manera rápida) 2.- Elijo un individuo al azar que interactua con uno de sus cuatro vecinos este, oeste, norte o sur, la probabilidad de interactuar depende de el número de características comunes que tenga con el resto. A más parecido más probable interactuar a menos menos. 3.- Cuando dos individuos interactuan uno copia una carácterística del otro. Se sigue el proceso a poder ser 80.000 veces (Con mi máquina ha sido imposible pasar de 8.000) (Fin del bucle) Os mando el bucle por si lo queréis correr. Pero la cosa no es que nadie me lo haga, es una cosa personal entre mi máquina y yo. De todas manera es demasiado código para leer, por eso no lo he mandado de primeras. #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- rm(list=ls()) #Parametros L<- 15 #Tamaño del grupo N=L*L N<-L*L #Sample size Fc<-2 #Number of commponents q<-3 #Number of commponent values p<-0.05 #Probability of remote conexion traits<-letters[1:q] #Numeric values is not a good idea for this exercise I prefer do with letters #---------------------------------------------------------- #Matriz de valores culturales M1<-matrix(NA, ncol=Fc+1, nrow=N) i<-1 for(i in 1:N){#Create vectors M1[i,-(Fc+1)]<- sample(traits, Fc, replace=T) M1[i,(Fc+1)]<- paste( M1[i,1:Fc], sep="", collapse="") } M2<-matrix(NA, nrow=N, ncol=2) M2[,2]<-rep(1:L,L) #unidades for(i in 1:L){ M2[(1+(i-1)*L):(L+(i-1)*L),1]<-rep(i,L) #Decenas de las coordenas } M<-cbind(M2,M1) #head(M) #---------------------------------------------------------- #Creamos los factores que definiran los colores colores<-rainbow(q^Fc) combn(x=traits,m=Fc)#Combina valores no nos vale combn(letters[1:4], 2, simplify=F) require(utils) lista<-NULL for(i in 1:Fc){ lista[[i]]<-traits #create a list for function expand.grid } factores<-interaction(lista,sep="") cbind(factores, colores) factores1<-levels(factores) #----------------------------------------------------------- #Creamos ahora el factor en la matriz de datos datos<-as.data.frame(M, stringsAsFactors=F) names(datos)[c(1,2)]<-c("x","y") names(datos)[2+Fc+1]<-c("factor") datos$factor<- factor(datos$factor, levels=factores1) datos[,c(1)]<-as.numeric(datos[,c(1)]) datos[,c(2)]<-as.numeric(datos[,c(2)]) head(datos) summary(datos) #-------------------------------------------------------------------------- #We calculate th interaction matrix #We can alocate the file and colum by row name with this algorithm # file %% L = y coordenade if is equal to zero we must plus one and # x coordenade is file %/% L = x coordenade # in other case file %/% L = x coordenade -1 #On other hand if we are in the border we only have 3 or 2 neighbours #Two if the point is a corner and 3 in other case. interac<-matrix(0,nrow=N,ncol=N) coordenades<-NULL coordenades<-as.data.frame(matrix(0,nrow=N, ncol=3)) names(coordenades)<-c("x","y","file") for ( i in 1:N){ if(i %% L!= 0){ coordenades[i,]$y<-i %% L coordenades[i,]$x<- i%/% L +1 }else{ coordenades[i,]$y<- L coordenades[i,]$x<- i%/% L } coordenades[i,]$file<-i } head(coordenades) #coordenades #Now we compute standard interacction matrix i<-1 for(i in 1:(N)){#central map values x<-coordenades[coordenades$file==i,]$x y<-coordenades[coordenades$file==i,]$y interac[i,coordenades[coordenades$x==(x+1) & coordenades$y==(y),]$file]<-1 interac[i,coordenades[coordenades$x==(x-1) & coordenades$y==(y),]$file]<-1 interac[i,coordenades[coordenades$x==(x) & coordenades$y==(y+1),]$file]<-1 interac[i,coordenades[coordenades$x==(x) & coordenades$y==(y-1),]$file]<-1 } #------------------------------------------------------------------------- plot(datos[,c(1,2)], col=colores[datos$factor],pch=15, cex=2 ,las=1, xlim=c(1,L), ylim=c(0.5,L+0.5)) title("n=0" ) rm(M,M1,M2,i,lista) #Variable names #factores1 contain al factor names #datos contain x and y coordenades trait of F dimensions(features) and the factor value #coordenades keep the relation between x and y coordenade and corresponde with data file number #interac all interacctions between elemets #colores all color pallet #L Tamaño del grupo N=L*L #N Sample size # Fc Number of commponents #q Number of commponent values #p Probability of remote conexion #traits Numeric values is not a good idea for this exercise I prefer do with letters #---------------------------------------------------------- head(datos) total<-8000 #datos11<-datps setwd("C:/Documents and Settings/UIB/Mis documentos/Dropbox/Máster/Física") #install.packages("animation") require(animation) ## A quick and dirty demo saveHTML({ #---------------------------------------------------------------------------------------------------------------------------- #Loop for Start html file for(k in 1:total){ aleatorio<-sample(1:N,1) #Selects one random element #aleatorio<-1 selected<-datos[aleatorio,] #Selected file neighboursIndex<-row(as.matrix(interac[aleatorio,]))[interac[aleatorio, ]==1] #Selects neighbours of our random element neighbours<-datos[neighboursIndex,] neighbours comunMeasure<-matrix(0, nrow=dim(neighbours)[1], ncol=dim(neighbours)[2]-3) #measures the comum values for(i in 3:(Fc+2)){ NumberN<-dim(neighbours)[1] #the number of neighbours measure for(j in 1:NumberN){ if( selected[,i]==neighbours[j,i]){ comunMeasure[j,i-2]<-1 #When is a neighbour } } } if(sum(apply(comunMeasure,1, sum))!=0){ ProbVect<-apply(comunMeasure,1, sum)/sum(apply(comunMeasure,1, sum)) selectedIndex<-sample(1:dim(neighbours)[1],prob=ProbVect, size=1 ) #Densitiy interaction function if is most similar is most probable of interact similar<- neighbours[selectedIndex,] #Select the most similar neighbour and we choose a different feature if any for change. if(sum(comunMeasure[selectedIndex,])!=Fc){ #Change different feature respect original or selected value change<-sample(row(as.matrix(comunMeasure[selectedIndex,]))[comunMeasure[selectedIndex, ]!=1],1) change<-change+2 similar[change]<-selected[change] similar$factor<-paste( similar[3:(Fc+2)], sep="", collapse="") similar } datos[rownames(similar),]<-similar datos[rownames(similar),] }else{ #No do anything } #plot(datos1[,c(1,2)], col=colores[datos1$factor],pch=15, cex=2 ,las=1, xlim=c(1,L), ylim=c(0.5,L+0.5)) plot(datos[,c(1,2)], col=colores[datos$factor],pch=15, cex=2 ,las=1, xlim=c(1,L), ylim=c(0.5,L+0.5)) title(paste("n=",k,sep="" )) print(paste(k ," de ",total, sep="")) } #finish loop for html file #---------------------------------------------------------------------------------------------------------------------------- }, img.name = "Axel", imgdir = "A50011", htmlfile "Axel1000.html",modelautobrowse = T, title = "Axelrof ", description = F , outdir=getwd()) El 12 de junio de 2012 16:06, Javier Villacampa González < javier.villacampa.gonzalez@gmail.com> escribió:> Lo primero gracias a todos, > Una de los problemas que me encontré fue al hacer modelos sociales para un > máster que estoy haciendo, aunque esta duda me surge habitualmente en mi > trabajo. La verdad es que por comodidad intento evitar vectorizar las > operaciones ya que a mi parecer hace incomodo el proceso de lectura, > sobretodo una vez pasados un par de meses. > > > > Ahora al lio, esto he sido incapaz de vectorizarlo y creo que lo voy a > intentar con c++... Estoy modelizando el modelo social Axelrof > # Info extra > # Artículo > # http://www-personal.umich.edu/~axe/research/Dissemination.pdf > # Tendría que quedar algo así > # http://ifisc.uib.es/research/APPLET_Axelrod/Culture.html > > #------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ > 1 Genero una matriz de datos nxn que representan individuos con unas > características, la conjunción de dichas características le da un color, > los individuos están distribuidos como un tablero de ajedrez en el plano. > (Empieza el bucle. > Este bucle se puede ver al final de este documento. Buscar > require(animation) con control +F si se quiere llegar al bucle de manera > rápida al bucle) > 2 Elijo un individuo al azar que interactua con uno de sus cuatro vecinos > este, oeste, norte o sur, la probabilidad de interactuar depende de el > número de características comunes que tenga con el resto a más parecido más > probable a menos menos. > > 3 Se cambia una caracterítstica y se sigue el proceso. A poder ser 80.000 > veces (imposible con mi máquina pasar de 8.000) > > (Fin del bucle) > Os mando el bucle por si lo quereis correr. Pero la cosa no es que nadie > me lo haga, es una cosa personal entre mi máquina y yo. De todas manera es > demasiado código para leer, por eso no lo he mandado de primeras. > > > #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > > #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > > #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > > #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > rm(list=ls()) > #Parametros > L<- 15 #Tamaño del grupo N=L*L > N<-L*L #Sample size > Fc<-2 #Number of commponents > q<-3 #Number of commponent values > p<-0.05 #Probability of remote conexion > traits<-letters[1:q] #Numeric values is not a good idea for this exercise > I prefer do with letters > #---------------------------------------------------------- > #Matriz de valores culturales > M1<-matrix(NA, ncol=Fc+1, nrow=N) > i<-1 > for(i in 1:N){#Create vectors > M1[i,-(Fc+1)]<- > sample(traits, Fc, replace=T) > M1[i,(Fc+1)]<- > paste( M1[i,1:Fc], sep="", collapse="") > } > > M2<-matrix(NA, nrow=N, ncol=2) > M2[,2]<-rep(1:L,L) #unidades > for(i in 1:L){ > M2[(1+(i-1)*L):(L+(i-1)*L),1]<-rep(i,L) #Decenas de las coordenas > } > M<-cbind(M2,M1) > #head(M) > #---------------------------------------------------------- > #Creamos los factores que definiran los colores > colores<-rainbow(q^Fc) > combn(x=traits,m=Fc)#Combina valores no nos vale > combn(letters[1:4], 2, simplify=F) > require(utils) > lista<-NULL > for(i in 1:Fc){ > lista[[i]]<-traits #create a list for function expand.grid > } > factores<-interaction(lista,sep="") > > > cbind(factores, colores) > > factores1<-levels(factores) > > #----------------------------------------------------------- > #Creamos ahora el factor en la matriz de datos > > datos<-as.data.frame(M, stringsAsFactors=F) > > names(datos)[c(1,2)]<-c("x","y") > names(datos)[2+Fc+1]<-c("factor") > datos$factor<- factor(datos$factor, levels=factores1) > datos[,c(1)]<-as.numeric(datos[,c(1)]) > datos[,c(2)]<-as.numeric(datos[,c(2)]) > head(datos) > summary(datos) > #-------------------------------------------------------------------------- > #We calculate th interaction matrix > #We can alocate the file and colum by row name with this algorithm > # file %% L = y coordenade if is equal to zero we must plus one and > # x coordenade is file %/% L = x coordenade > # in other case file %/% L = x coordenade -1 > > #On other hand if we are in the border we only have 3 or 2 neighbours > #Two if the point is a corner and 3 in other case. > interac<-matrix(0,nrow=N,ncol=N) > coordenades<-NULL > coordenades<-as.data.frame(matrix(0,nrow=N, ncol=3)) > names(coordenades)<-c("x","y","file") > > for ( i in 1:N){ > if(i %% L!= 0){ > coordenades[i,]$y<-i %% L > coordenades[i,]$x<- i%/% L +1 > }else{ > coordenades[i,]$y<- L > coordenades[i,]$x<- i%/% L > } > coordenades[i,]$file<-i > } > > head(coordenades) > #coordenades > #Now we compute standard interacction matrix > i<-1 > for(i in 1:(N)){#central map values > x<-coordenades[coordenades$file==i,]$x > y<-coordenades[coordenades$file==i,]$y > interac[i,coordenades[coordenades$x==(x+1) & > coordenades$y==(y),]$file]<-1 > interac[i,coordenades[coordenades$x==(x-1) & > coordenades$y==(y),]$file]<-1 > interac[i,coordenades[coordenades$x==(x) & > coordenades$y==(y+1),]$file]<-1 > interac[i,coordenades[coordenades$x==(x) & > coordenades$y==(y-1),]$file]<-1 > } > > #------------------------------------------------------------------------- > plot(datos[,c(1,2)], col=colores[datos$factor],pch=15, cex=2 ,las=1, > xlim=c(1,L), ylim=c(0.5,L+0.5)) > title("n=0" ) > rm(M,M1,M2,i,lista) > #Variable names > #factores1 contain al factor names > #datos contain x and y coordenades trait of F dimensions(features) and the > factor value > #coordenades keep the relation between x and y coordenade and corresponde > with data file number > #interac all interacctions between elemets > #colores all color pallet > #L Tamaño del grupo N=L*L > #N Sample size > # Fc Number of commponents > #q Number of commponent values > #p Probability of remote conexion > #traits Numeric values is not a good idea for this exercise I prefer do > with letters > #---------------------------------------------------------- > head(datos) > > > > total<-8000 > #datos11<-datps > setwd("C:/Documents and Settings/UIB/Mis documentos/Dropbox/Máster/Física") > #install.packages("animation") > require(animation) > ## A quick and dirty demo > saveHTML({ > > #---------------------------------------------------------------------------------------------------------------------------- > #Loop for Start html file > for(k in 1:total){ > aleatorio<-sample(1:N,1) #Selects one random element > #aleatorio<-1 > selected<-datos[aleatorio,] #Selected file > > neighboursIndex<-row(as.matrix(interac[aleatorio,]))[interac[aleatorio, > ]==1] #Selects neighbours of our random element > neighbours<-datos[neighboursIndex,] > neighbours > comunMeasure<-matrix(0, nrow=dim(neighbours)[1], > ncol=dim(neighbours)[2]-3) #measures the comum values > for(i in 3:(Fc+2)){ > NumberN<-dim(neighbours)[1] #the number of neighbours measure > for(j in 1:NumberN){ > if( selected[,i]==neighbours[j,i]){ > comunMeasure[j,i-2]<-1 #When is a neighbour > } > } > > } > > if(sum(apply(comunMeasure,1, sum))!=0){ > ProbVect<-apply(comunMeasure,1, sum)/sum(apply(comunMeasure,1, sum)) > selectedIndex<-sample(1:dim(neighbours)[1],prob=ProbVect, size=1 ) > #Densitiy interaction function if is most similar is most probable of > interact > similar<- > neighbours[selectedIndex,] #Select the most similar neighbour and > we choose a different feature if any for change. > > if(sum(comunMeasure[selectedIndex,])!=Fc){ #Change different feature > respect original or selected value > > change<-sample(row(as.matrix(comunMeasure[selectedIndex,]))[comunMeasure[selectedIndex, > ]!=1],1) > change<-change+2 > similar[change]<-selected[change] > similar$factor<-paste( similar[3:(Fc+2)], sep="", collapse="") > similar > } > > datos[rownames(similar),]<-similar > datos[rownames(similar),] > > > }else{ > #No do anything > } > #plot(datos1[,c(1,2)], col=colores[datos1$factor],pch=15, cex=2 > ,las=1, xlim=c(1,L), ylim=c(0.5,L+0.5)) > plot(datos[,c(1,2)], col=colores[datos$factor],pch=15, cex=2 ,las=1, > xlim=c(1,L), ylim=c(0.5,L+0.5)) > title(paste("n=",k,sep="" )) > print(paste(k ," de ",total, sep="")) > > } > > #finish loop for html file > > #---------------------------------------------------------------------------------------------------------------------------- > }, img.name = "Axel", imgdir = "A50011", htmlfile > "Axel1000.html",modelautobrowse = T, title = "Axelrof ", > description = F , outdir=getwd()) > > > El 12 de junio de 2012 14:32, Javier Villacampa González < > javier.villacampa.gonzalez@gmail.com> escribió: > >> Buenas días a todos, >> >> >> una vez más os escribo para preguntaros una duda. Estoy haciendo bucles >> con data frames, el problema es que al hacer bucles de esta manera el >> sistema se relentiza. He buscado por internet y en varias web te dicen que >> evites los bucles en la medida de lo posible y que intentes funcionar con >> c++ con la librería Rccp >> http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. >> >> Mi preguta es >> 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje >> 2 Alguna página con ejemplitos fáciles de Rccp. >> >> Como ya veis tengo la duda a medio madurar, pero si me podeis dar un >> empujón os lo agradeceré. >> >> Un saludo y gracias por adelantado. >> > >[[alternative HTML version deleted]]
Vaya Javier, No estaba al tanto de que se estaba trabajando en un compilador. Tiene muy buena pinta como solución intermedia a programar en C directamente!! El 12 de junio de 2012 15:33, Marcuzzi, Javier Rubén < javier.ruben.marcuzzi@gmail.com> escribió:> Estimado González > > Si. Compilando. Yo realicé una prueba muy sencilla es es mucho más veloz, > claro, esta posibilidad existe en la última versión de R. > > Javier Marcuzzi > > -----Mensaje original----- From: Javier Villacampa González > Sent: Tuesday, June 12, 2012 9:32 AM > To: r-help-es@r-project.org > Subject: [R-es] help: Bucles rápidos en R > > > Buenas días a todos, > > una vez más os escribo para preguntaros una duda. Estoy haciendo bucles con > data frames, el problema es que al hacer bucles de esta manera el sistema > se relentiza. He buscado por internet y en varias web te dicen que evites > los bucles en la medida de lo posible y que intentes funcionar con c++ con > la librería Rccp http://cran.r-project.org/web/**packages/Rcpp/Rcpp.pdf<http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf> > . > > Mi preguta es > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje > 2 Alguna página con ejemplitos fáciles de Rccp. > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar un > empujón os lo agradeceré. > > Un saludo y gracias por adelantado. > > [[alternative HTML version deleted]] > > > > > > > > ______________________________**_________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/**listinfo/r-help-es<https://stat.ethz.ch/mailman/listinfo/r-help-es> > > ______________________________**_________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/**listinfo/r-help-es<https://stat.ethz.ch/mailman/listinfo/r-help-es> >[[alternative HTML version deleted]]
Fernando Los loops basados en FOR son muy ineficientes en R. Casi siempre pueden ser substituidos aplicando las funciones apply, lapply, sapply... que mejoran dramaticamente la performance. Prof. Julio Di Rienzo Estadística y Biometría FCA- U.N. Córdoba IBS-RARG President http://sites.google.com/site/juliodirienzo "Biometry, the active pursuit of biological knowledge by quantitative methods." (R.A. Fisher, 1948) 2012/6/12 Fernando Fernández <fernando.fernandez.gonzalez@gmail.com>> Vaya Javier, > > No estaba al tanto de que se estaba trabajando en un compilador. Tiene muy > buena pinta como solución intermedia a programar en C directamente!! > > > > El 12 de junio de 2012 15:33, Marcuzzi, Javier Rubén < > javier.ruben.marcuzzi@gmail.com> escribió: > > > Estimado González > > > > Si. Compilando. Yo realicé una prueba muy sencilla es es mucho más veloz, > > claro, esta posibilidad existe en la última versión de R. > > > > Javier Marcuzzi > > > > -----Mensaje original----- From: Javier Villacampa González > > Sent: Tuesday, June 12, 2012 9:32 AM > > To: r-help-es@r-project.org > > Subject: [R-es] help: Bucles rápidos en R > > > > > > Buenas días a todos, > > > > una vez más os escribo para preguntaros una duda. Estoy haciendo bucles > con > > data frames, el problema es que al hacer bucles de esta manera el sistema > > se relentiza. He buscado por internet y en varias web te dicen que evites > > los bucles en la medida de lo posible y que intentes funcionar con c++ > con > > la librería Rccp http://cran.r-project.org/web/**packages/Rcpp/Rcpp.pdf< > http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf> > > . > > > > Mi preguta es > > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje > > 2 Alguna página con ejemplitos fáciles de Rccp. > > > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar un > > empujón os lo agradeceré. > > > > Un saludo y gracias por adelantado. > > > > [[alternative HTML version deleted]] > > > > > > > > > > > > > > > > ______________________________**_________________ > > R-help-es mailing list > > R-help-es@r-project.org > > https://stat.ethz.ch/mailman/**listinfo/r-help-es< > https://stat.ethz.ch/mailman/listinfo/r-help-es> > > > > ______________________________**_________________ > > R-help-es mailing list > > R-help-es@r-project.org > > https://stat.ethz.ch/mailman/**listinfo/r-help-es< > https://stat.ethz.ch/mailman/listinfo/r-help-es> > > > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >[[alternative HTML version deleted]]
Hola, Puedes acelerar los bucles que tienes transformándolos en funciones y utilizar la función cmpfun() del paquete compiler. Mira aquí algunos ejemplos de aplicación: http://www.r-statistics.com/2012/04/speed-up-your-r-code-using-a-just-in-time-jit-compiler/ Y aunque creo que esta otra ayuda es más tangencial, podría venirte bien intentan reproducir este modelo Axelrod (que es un caso de un autómata en 2D) pero en una dimensión utilizando el paquete CellularAutomation. Saludos, Carlos Ortega www.qualityexcellence.es El 12 de junio de 2012 16:06, Javier Villacampa González < javier.villacampa.gonzalez@gmail.com> escribió:> Lo primero gracias a todos, > Una de los problemas que me encontré fue al hacer modelos sociales para un > máster que estoy haciendo, aunque esta duda me surge habitualmente en mi > trabajo. La verdad es que por comodidad intento evitar vectorizar las > operaciones ya que a mi parecer hace incomodo el proceso de lectura, > sobretodo una vez pasados un par de meses. > > > > Ahora al lio, esto he sido incapaz de vectorizarlo y creo que lo voy a > intentar con c++... Estoy modelizando el modelo social Axelrof > # Info extra > # Artículo > # http://www-personal.umich.edu/~axe/research/Dissemination.pdf > # Tendría que quedar algo así > # http://ifisc.uib.es/research/APPLET_Axelrod/Culture.html > > #------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ > 1 Genero una matriz de datos nxn que representan individuos con unas > características, la conjunción de dichas características le da un color, > los individuos están distribuidos como un tablero de ajedrez en el plano. > (Empieza el bucle. > Este bucle se puede ver al final de este documento. Buscar > require(animation) con control +F si se quiere llegar al bucle de manera > rápida al bucle) > 2 Elijo un individuo al azar que interactua con uno de sus cuatro vecinos > este, oeste, norte o sur, la probabilidad de interactuar depende de el > número de características comunes que tenga con el resto a más parecido más > probable a menos menos. > > 3 Se cambia una caracterítstica y se sigue el proceso. A poder ser 80.000 > veces (imposible con mi máquina pasar de 8.000) > > (Fin del bucle) > Os mando el bucle por si lo quereis correr. Pero la cosa no es que nadie me > lo haga, es una cosa personal entre mi máquina y yo. De todas manera es > demasiado código para leer, por eso no lo he mandado de primeras. > > > #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > > #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > > #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > > #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > rm(list=ls()) > #Parametros > L<- 15 #Tamaño del grupo N=L*L > N<-L*L #Sample size > Fc<-2 #Number of commponents > q<-3 #Number of commponent values > p<-0.05 #Probability of remote conexion > traits<-letters[1:q] #Numeric values is not a good idea for this exercise I > prefer do with letters > #---------------------------------------------------------- > #Matriz de valores culturales > M1<-matrix(NA, ncol=Fc+1, nrow=N) > i<-1 > for(i in 1:N){#Create vectors > M1[i,-(Fc+1)]<- > sample(traits, Fc, replace=T) > M1[i,(Fc+1)]<- > paste( M1[i,1:Fc], sep="", collapse="") > } > > M2<-matrix(NA, nrow=N, ncol=2) > M2[,2]<-rep(1:L,L) #unidades > for(i in 1:L){ > M2[(1+(i-1)*L):(L+(i-1)*L),1]<-rep(i,L) #Decenas de las coordenas > } > M<-cbind(M2,M1) > #head(M) > #---------------------------------------------------------- > #Creamos los factores que definiran los colores > colores<-rainbow(q^Fc) > combn(x=traits,m=Fc)#Combina valores no nos vale > combn(letters[1:4], 2, simplify=F) > require(utils) > lista<-NULL > for(i in 1:Fc){ > lista[[i]]<-traits #create a list for function expand.grid > } > factores<-interaction(lista,sep="") > > > cbind(factores, colores) > > factores1<-levels(factores) > > #----------------------------------------------------------- > #Creamos ahora el factor en la matriz de datos > > datos<-as.data.frame(M, stringsAsFactors=F) > > names(datos)[c(1,2)]<-c("x","y") > names(datos)[2+Fc+1]<-c("factor") > datos$factor<- factor(datos$factor, levels=factores1) > datos[,c(1)]<-as.numeric(datos[,c(1)]) > datos[,c(2)]<-as.numeric(datos[,c(2)]) > head(datos) > summary(datos) > #-------------------------------------------------------------------------- > #We calculate th interaction matrix > #We can alocate the file and colum by row name with this algorithm > # file %% L = y coordenade if is equal to zero we must plus one and > # x coordenade is file %/% L = x coordenade > # in other case file %/% L = x coordenade -1 > > #On other hand if we are in the border we only have 3 or 2 neighbours > #Two if the point is a corner and 3 in other case. > interac<-matrix(0,nrow=N,ncol=N) > coordenades<-NULL > coordenades<-as.data.frame(matrix(0,nrow=N, ncol=3)) > names(coordenades)<-c("x","y","file") > > for ( i in 1:N){ > if(i %% L!= 0){ > coordenades[i,]$y<-i %% L > coordenades[i,]$x<- i%/% L +1 > }else{ > coordenades[i,]$y<- L > coordenades[i,]$x<- i%/% L > } > coordenades[i,]$file<-i > } > > head(coordenades) > #coordenades > #Now we compute standard interacction matrix > i<-1 > for(i in 1:(N)){#central map values > x<-coordenades[coordenades$file==i,]$x > y<-coordenades[coordenades$file==i,]$y > interac[i,coordenades[coordenades$x==(x+1) & coordenades$y==(y),]$file]<-1 > interac[i,coordenades[coordenades$x==(x-1) & coordenades$y==(y),]$file]<-1 > interac[i,coordenades[coordenades$x==(x) & coordenades$y==(y+1),]$file]<-1 > interac[i,coordenades[coordenades$x==(x) & coordenades$y==(y-1),]$file]<-1 > } > > #------------------------------------------------------------------------- > plot(datos[,c(1,2)], col=colores[datos$factor],pch=15, cex=2 ,las=1, > xlim=c(1,L), ylim=c(0.5,L+0.5)) > title("n=0" ) > rm(M,M1,M2,i,lista) > #Variable names > #factores1 contain al factor names > #datos contain x and y coordenades trait of F dimensions(features) and the > factor value > #coordenades keep the relation between x and y coordenade and corresponde > with data file number > #interac all interacctions between elemets > #colores all color pallet > #L Tamaño del grupo N=L*L > #N Sample size > # Fc Number of commponents > #q Number of commponent values > #p Probability of remote conexion > #traits Numeric values is not a good idea for this exercise I prefer do > with letters > #---------------------------------------------------------- > head(datos) > > > > total<-8000 > #datos11<-datps > setwd("C:/Documents and Settings/UIB/Mis documentos/Dropbox/Máster/Física") > #install.packages("animation") > require(animation) > ## A quick and dirty demo > saveHTML({ > > #---------------------------------------------------------------------------------------------------------------------------- > #Loop for Start html file > for(k in 1:total){ > aleatorio<-sample(1:N,1) #Selects one random element > #aleatorio<-1 > selected<-datos[aleatorio,] #Selected file > neighboursIndex<-row(as.matrix(interac[aleatorio,]))[interac[aleatorio, > ]==1] #Selects neighbours of our random element > neighbours<-datos[neighboursIndex,] > neighbours > comunMeasure<-matrix(0, nrow=dim(neighbours)[1], > ncol=dim(neighbours)[2]-3) #measures the comum values > for(i in 3:(Fc+2)){ > NumberN<-dim(neighbours)[1] #the number of neighbours measure > for(j in 1:NumberN){ > if( selected[,i]==neighbours[j,i]){ > comunMeasure[j,i-2]<-1 #When is a neighbour > } > } > > } > > if(sum(apply(comunMeasure,1, sum))!=0){ > ProbVect<-apply(comunMeasure,1, sum)/sum(apply(comunMeasure,1, sum)) > selectedIndex<-sample(1:dim(neighbours)[1],prob=ProbVect, size=1 ) > #Densitiy interaction function if is most similar is most probable of > interact > similar<- > neighbours[selectedIndex,] #Select the most similar neighbour and > we choose a different feature if any for change. > > if(sum(comunMeasure[selectedIndex,])!=Fc){ #Change different feature > respect original or selected value > > > change<-sample(row(as.matrix(comunMeasure[selectedIndex,]))[comunMeasure[selectedIndex, > ]!=1],1) > change<-change+2 > similar[change]<-selected[change] > similar$factor<-paste( similar[3:(Fc+2)], sep="", collapse="") > similar > } > > datos[rownames(similar),]<-similar > datos[rownames(similar),] > > > }else{ > #No do anything > } > #plot(datos1[,c(1,2)], col=colores[datos1$factor],pch=15, cex=2 ,las=1, > xlim=c(1,L), ylim=c(0.5,L+0.5)) > plot(datos[,c(1,2)], col=colores[datos$factor],pch=15, cex=2 ,las=1, > xlim=c(1,L), ylim=c(0.5,L+0.5)) > title(paste("n=",k,sep="" )) > print(paste(k ," de ",total, sep="")) > > } > > #finish loop for html file > > #---------------------------------------------------------------------------------------------------------------------------- > }, img.name = "Axel", imgdir = "A50011", htmlfile > "Axel1000.html",modelautobrowse = T, title = "Axelrof ", > description = F , outdir=getwd()) > > > El 12 de junio de 2012 14:32, Javier Villacampa González < > javier.villacampa.gonzalez@gmail.com> escribió: > > > Buenas días a todos, > > > > una vez más os escribo para preguntaros una duda. Estoy haciendo bucles > > con data frames, el problema es que al hacer bucles de esta manera el > > sistema se relentiza. He buscado por internet y en varias web te dicen > que > > evites los bucles en la medida de lo posible y que intentes funcionar con > > c++ con la librería Rccp > > http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. > > > > Mi preguta es > > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje > > 2 Alguna página con ejemplitos fáciles de Rccp. > > > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar un > > empujón os lo agradeceré. > > > > Un saludo y gracias por adelantado. > > > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >-- Saludos, Carlos Ortega www.qualityexcellence.es [[alternative HTML version deleted]]
Estimados Julio, Javier Villacampa, Fernando y Javier Marcuzzi, Es indudable que los for() han sido comentados extensamente en esta y otras listas, y que la preferencia ha sido, en ciertos escenarios, trabajar con las funciones *apply. Sin embargo, los for() no son del todo tan ineficientes como muchos piensan (o pensaban, me incluyo), y todo depende de como comience el proceso (para algunas ideas ver "Circle 2" en "R Inferno" de Patrick Burns). La ventaja de usar *apply frente a los for() es que, en general, se encargan de darle formato al objeto resultante. Por el contrario, con los for() hay que trabajar un poco mas "antes de" comenzar a trabajar. Personalmente que esta discusion es muy productiva y podria dejarnos muchas enseñanzas, sobretodo a aquellos que recien comienzan con R. Como otros han dicho, la vectorizacion de funciones es deseable, pero desafortunadamente a veces toma mas tiempo crear esa funcion que esperar a que termine el for(). Quizas no sea el mejor ejemplo, pero he aqui una pequeña comparacion: # numero de muestras B <- 1000 # --------------------------------------- # generacion de B muestras de # tamaño B de una N(0,1) # --------------------------------------- # creando el objeto "antes de" set.seed(123) r1 <- vector("list", B) system.time({ for(i in 1:B) r1[[i]] <- rnorm(i) }) # creando el objeto "on the fly" set.seed(123) system.time(r2 <- lapply(1:B, rnorm)) # usando replicate() set.seed(123) system.time(r3 <- lapply(1:B, function(b) rnorm(b))) # iguales? all.equal(r1, r2) all.equal(r2, r3) all.equal(r1, r3) Saludos, Jorge.- 2012/6/12 Julio Alejandro Di Rienzo <>> Fernando > > Los loops basados en FOR son muy ineficientes en R. > Casi siempre pueden ser substituidos aplicando las funciones apply, lapply, > sapply... que mejoran dramaticamente la performance. > > Prof. Julio Di Rienzo > Estadística y Biometría > FCA- U.N. Córdoba > IBS-RARG President > http://sites.google.com/site/juliodirienzo > "Biometry, the active pursuit of biological > knowledge by quantitative methods." > (R.A. Fisher, 1948) > > > > 2012/6/12 Fernando Fernández <> > > > Vaya Javier, > > > > No estaba al tanto de que se estaba trabajando en un compilador. Tiene > muy > > buena pinta como solución intermedia a programar en C directamente!! > > > > > > > > El 12 de junio de 2012 15:33, Marcuzzi, Javier Rubén < > > <javier.ruben.marcuzzi@gmail.com>> escribió: > > > > > Estimado González > > > > > > Si. Compilando. Yo realicé una prueba muy sencilla es es mucho más > veloz, > > > claro, esta posibilidad existe en la última versión de R. > > > > > > Javier Marcuzzi > > > > > > -----Mensaje original----- From: Javier Villacampa González > > > Sent: Tuesday, June 12, 2012 9:32 AM > > > To: r-help-es@r-project.org > > > Subject: [R-es] help: Bucles rápidos en R > > > > > > > > > Buenas días a todos, > > > > > > una vez más os escribo para preguntaros una duda. Estoy haciendo bucles > > con > > > data frames, el problema es que al hacer bucles de esta manera el > sistema > > > se relentiza. He buscado por internet y en varias web te dicen que > evites > > > los bucles en la medida de lo posible y que intentes funcionar con c++ > > con > > > la librería Rccp > http://cran.r-project.org/web/**packages/Rcpp/Rcpp.pdf< > > http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf> > > > . > > > > > > Mi preguta es > > > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje > > > 2 Alguna página con ejemplitos fáciles de Rccp. > > > > > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar un > > > empujón os lo agradeceré. > > > > > > Un saludo y gracias por adelantado. > > > > > > [[alternative HTML version deleted]] > > > > > > > > > > > > > > > > > > > > > > > > ______________________________**_________________ > > > R-help-es mailing list > > > R-help-es@r-project.org > > > https://stat.ethz.ch/mailman/**listinfo/r-help-es< > > https://stat.ethz.ch/mailman/listinfo/r-help-es> > > > > > > ______________________________**_________________ > > > R-help-es mailing list > > > R-help-es@r-project.org > > > https://stat.ethz.ch/mailman/**listinfo/r-help-es< > > https://stat.ethz.ch/mailman/listinfo/r-help-es> > > > > > > > [[alternative HTML version deleted]] > > > > > > _______________________________________________ > > R-help-es mailing list > > R-help-es@r-project.org > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >[[alternative HTML version deleted]]
Hola, ¿qué tal? Fernando, me interesa mucho la sugerencia que haces a Javier, pero no consigo llevarla a la práctica. Me da este error:> x[x[>3]] <- 3Error: inesperado ''>'' en "x[x[>" Por favor, ¿podrías poner un ejemplo desde cero?. Gracias. Eva --- El mar, 12/6/12, Fernando Fernández <fernando.fernandez.gonzalez@gmail.com> escribió: De: Fernando Fernández <fernando.fernandez.gonzalez@gmail.com> Asunto: Re: [R-es] help: Bucles rápidos en R Para: "Javier Villacampa González" <javier.villacampa.gonzalez@gmail.com> CC: r-help-es@r-project.org Fecha: martes, 12 de junio, 2012 15:19 Las funciones apply, lapply, sapply, tapply son tus amigas... También es bastante posible que estés haciendo tareas con bucles que se pueden escribir con instrucciones matriciales y subíndices. Del tipo: x[x[>3]]<-3 en lugar de: for(i in 1:length(x)){ if x[i]>3 then x[i]<-3 } Mi recomendacion es que antes de seguir programando te recorras los ejemplos de dos o tres manuales diferentes que suelen tener ejemplos de como aprovechar estas instrucciones en R (Los que puedes encontrar en CRAN deberían servirte). Merece la pena invertir algo de tiempo en aprender a sacarles partido. El 12 de junio de 2012 14:32, Javier Villacampa González < javier.villacampa.gonzalez@gmail.com> escribió:> Buenas días a todos, > > una vez más os escribo para preguntaros una duda. Estoy haciendo bucles con > data frames, el problema es que al hacer bucles de esta manera el sistema > se relentiza. He buscado por internet y en varias web te dicen que evites > los bucles en la medida de lo posible y que intentes funcionar con c++ con > la librería Rccp http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. > > Mi preguta es > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje > 2 Alguna página con ejemplitos fáciles de Rccp. > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar un > empujón os lo agradeceré. > > Un saludo y gracias por adelantado. > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >[[alternative HTML version deleted]] -----Adjunto en línea a continuación----- _______________________________________________ R-help-es mailing list R-help-es@r-project.org https://stat.ethz.ch/mailman/listinfo/r-help-es [[alternative HTML version deleted]]
Hola Eva, A continuacion un ejemplo: x <- rpois(20, 10) x x[x > 10] <- -20 x Un saludo, Jorge.- 2012/6/12 Eva Prieto Castro <>> Hola, ¿qué tal? > > Fernando, me interesa mucho la sugerencia que haces a Javier, pero no > consigo llevarla a la práctica. > > Me da este error: > > > x[x[>3]] <- 3 > Error: inesperado ''>'' en "x[x[>" > > Por favor, ¿podrías poner un ejemplo desde cero?. Gracias. > > Eva > > --- El mar, 12/6/12, Fernando Fernández <> escribió: > > De: Fernando Fernández <> > Asunto: Re: [R-es] help: Bucles rápidos en R > Para: "Javier Villacampa González" <javier.villacampa.gonzalez@gmail.com> > CC: r-help-es@r-project.org > Fecha: martes, 12 de junio, 2012 15:19 > > Las funciones apply, lapply, sapply, tapply son tus amigas... También es > bastante posible que estés haciendo tareas con bucles que se pueden > escribir con instrucciones matriciales y subíndices. Del tipo: > > x[x[>3]]<-3 > > en lugar de: > > for(i in 1:length(x)){ > if x[i]>3 then > x[i]<-3 > } > > Mi recomendacion es que antes de seguir programando te recorras los > ejemplos de dos o tres manuales diferentes que suelen tener ejemplos de > como aprovechar estas instrucciones en R (Los que puedes encontrar en CRAN > deberían servirte). Merece la pena invertir algo de tiempo en aprender a > sacarles partido. > > El 12 de junio de 2012 14:32, Javier Villacampa González < > javier.villacampa.gonzalez@gmail.com> escribió: > > > Buenas días a todos, > > > > una vez más os escribo para preguntaros una duda. Estoy haciendo bucles > con > > data frames, el problema es que al hacer bucles de esta manera el sistema > > se relentiza. He buscado por internet y en varias web te dicen que evites > > los bucles en la medida de lo posible y que intentes funcionar con c++ > con > > la librería Rccp http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. > > > > Mi preguta es > > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje > > 2 Alguna página con ejemplitos fáciles de Rccp. > > > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar un > > empujón os lo agradeceré. > > > > Un saludo y gracias por adelantado. > > > > [[alternative HTML version deleted]] > > > > > > _______________________________________________ > > R-help-es mailing list > > R-help-es@r-project.org > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > [[alternative HTML version deleted]] > > > -----Adjunto en línea a continuación----- > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >[[alternative HTML version deleted]]
Efectivamente, quería decir eso, no se en qué estaba pensndo para poner el segundo par de corchetes... Cuando veo a alguien escribir bucles for para hacer cosas así por no haber dedicado unas horas a ojear algún manual de R... El 12 de junio de 2012 20:01, Jorge I Velez <jorgeivanvelez@gmail.com>escribió:> Hola Eva, > > A continuacion un ejemplo: > > x <- rpois(20, 10) > x > x[x > 10] <- -20 > x > > Un saludo, > Jorge.- > > > 2012/6/12 Eva Prieto Castro <> > > > Hola, ¿qué tal? > > > > Fernando, me interesa mucho la sugerencia que haces a Javier, pero no > > consigo llevarla a la práctica. > > > > Me da este error: > > > > > x[x[>3]] <- 3 > > Error: inesperado ''>'' en "x[x[>" > > > > Por favor, ¿podrías poner un ejemplo desde cero?. Gracias. > > > > Eva > > > > --- El mar, 12/6/12, Fernando Fernández <> escribió: > > > > De: Fernando Fernández <> > > Asunto: Re: [R-es] help: Bucles rápidos en R > > Para: "Javier Villacampa González" <javier.villacampa.gonzalez@gmail.com > > > > CC: r-help-es@r-project.org > > Fecha: martes, 12 de junio, 2012 15:19 > > > > Las funciones apply, lapply, sapply, tapply son tus amigas... También es > > bastante posible que estés haciendo tareas con bucles que se pueden > > escribir con instrucciones matriciales y subíndices. Del tipo: > > > > x[x[>3]]<-3 > > > > en lugar de: > > > > for(i in 1:length(x)){ > > if x[i]>3 then > > x[i]<-3 > > } > > > > Mi recomendacion es que antes de seguir programando te recorras los > > ejemplos de dos o tres manuales diferentes que suelen tener ejemplos de > > como aprovechar estas instrucciones en R (Los que puedes encontrar en > CRAN > > deberían servirte). Merece la pena invertir algo de tiempo en aprender a > > sacarles partido. > > > > El 12 de junio de 2012 14:32, Javier Villacampa González < > > javier.villacampa.gonzalez@gmail.com> escribió: > > > > > Buenas días a todos, > > > > > > una vez más os escribo para preguntaros una duda. Estoy haciendo bucles > > con > > > data frames, el problema es que al hacer bucles de esta manera el > sistema > > > se relentiza. He buscado por internet y en varias web te dicen que > evites > > > los bucles en la medida de lo posible y que intentes funcionar con c++ > > con > > > la librería Rccp http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. > > > > > > Mi preguta es > > > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje > > > 2 Alguna página con ejemplitos fáciles de Rccp. > > > > > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar un > > > empujón os lo agradeceré. > > > > > > Un saludo y gracias por adelantado. > > > > > > [[alternative HTML version deleted]] > > > > > > > > > _______________________________________________ > > > R-help-es mailing list > > > R-help-es@r-project.org > > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > > > > > [[alternative HTML version deleted]] > > > > > > -----Adjunto en línea a continuación----- > > > > _______________________________________________ > > R-help-es mailing list > > R-help-es@r-project.org > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > [[alternative HTML version deleted]] > > > > > > _______________________________________________ > > R-help-es mailing list > > R-help-es@r-project.org > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >[[alternative HTML version deleted]]
¡Ojo que apply y sus variaciones no son más que un loop disfrazado! Luciano El 12 de junio de 2012 18:52, Fernando Fernández < fernando.fernandez.gonzalez@gmail.com> escribió:> Efectivamente, quería decir eso, no se en qué estaba pensndo para poner el > segundo par de corchetes... > > Cuando veo a alguien escribir bucles for para hacer cosas así por no haber > dedicado unas horas a ojear algún manual de R... > > El 12 de junio de 2012 20:01, Jorge I Velez <jorgeivanvelez@gmail.com > >escribió: > > > Hola Eva, > > > > A continuacion un ejemplo: > > > > x <- rpois(20, 10) > > x > > x[x > 10] <- -20 > > x > > > > Un saludo, > > Jorge.- > > > > > > 2012/6/12 Eva Prieto Castro <> > > > > > Hola, ¿qué tal? > > > > > > Fernando, me interesa mucho la sugerencia que haces a Javier, pero no > > > consigo llevarla a la práctica. > > > > > > Me da este error: > > > > > > > x[x[>3]] <- 3 > > > Error: inesperado ''>'' en "x[x[>" > > > > > > Por favor, ¿podrías poner un ejemplo desde cero?. Gracias. > > > > > > Eva > > > > > > --- El mar, 12/6/12, Fernando Fernández <> escribió: > > > > > > De: Fernando Fernández <> > > > Asunto: Re: [R-es] help: Bucles rápidos en R > > > Para: "Javier Villacampa González" < > javier.villacampa.gonzalez@gmail.com > > > > > > CC: r-help-es@r-project.org > > > Fecha: martes, 12 de junio, 2012 15:19 > > > > > > Las funciones apply, lapply, sapply, tapply son tus amigas... También > es > > > bastante posible que estés haciendo tareas con bucles que se pueden > > > escribir con instrucciones matriciales y subíndices. Del tipo: > > > > > > x[x[>3]]<-3 > > > > > > en lugar de: > > > > > > for(i in 1:length(x)){ > > > if x[i]>3 then > > > x[i]<-3 > > > } > > > > > > Mi recomendacion es que antes de seguir programando te recorras los > > > ejemplos de dos o tres manuales diferentes que suelen tener ejemplos de > > > como aprovechar estas instrucciones en R (Los que puedes encontrar en > > CRAN > > > deberían servirte). Merece la pena invertir algo de tiempo en aprender > a > > > sacarles partido. > > > > > > El 12 de junio de 2012 14:32, Javier Villacampa González < > > > javier.villacampa.gonzalez@gmail.com> escribió: > > > > > > > Buenas días a todos, > > > > > > > > una vez más os escribo para preguntaros una duda. Estoy haciendo > bucles > > > con > > > > data frames, el problema es que al hacer bucles de esta manera el > > sistema > > > > se relentiza. He buscado por internet y en varias web te dicen que > > evites > > > > los bucles en la medida de lo posible y que intentes funcionar con > c++ > > > con > > > > la librería Rccp > http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. > > > > > > > > Mi preguta es > > > > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje > > > > 2 Alguna página con ejemplitos fáciles de Rccp. > > > > > > > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar un > > > > empujón os lo agradeceré. > > > > > > > > Un saludo y gracias por adelantado. > > > > > > > > [[alternative HTML version deleted]] > > > > > > > > > > > > _______________________________________________ > > > > R-help-es mailing list > > > > R-help-es@r-project.org > > > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > > > > > > > > > [[alternative HTML version deleted]] > > > > > > > > > -----Adjunto en línea a continuación----- > > > > > > _______________________________________________ > > > R-help-es mailing list > > > R-help-es@r-project.org > > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > [[alternative HTML version deleted]] > > > > > > > > > _______________________________________________ > > > R-help-es mailing list > > > R-help-es@r-project.org > > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > > > > > [[alternative HTML version deleted]] > > > > > > _______________________________________________ > > R-help-es mailing list > > R-help-es@r-project.org > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >[[alternative HTML version deleted]]
Apply y sus variaciones son más que un loop disfrazado y existes sus versiones paralelizables que son escensiales para manejar problemas grandes como applicar un modelo lineal mixtos complejo a una matriz de expresión génica con 63k genes. Prof. Julio Di Rienzo Estadística y Biometría FCA- U.N. Córdoba IBS-RARG President http://sites.google.com/site/juliodirienzo "Biometry, the active pursuit of biological knowledge by quantitative methods." (R.A. Fisher, 1948) 2012/6/14 Luciano Selzer <luciano.selzer@gmail.com>> ¡Ojo que apply y sus variaciones no son más que un loop disfrazado! > Luciano > > > El 12 de junio de 2012 18:52, Fernando Fernández < > fernando.fernandez.gonzalez@gmail.com> escribió: > > > Efectivamente, quería decir eso, no se en qué estaba pensndo para poner > el > > segundo par de corchetes... > > > > Cuando veo a alguien escribir bucles for para hacer cosas así por no > haber > > dedicado unas horas a ojear algún manual de R... > > > > El 12 de junio de 2012 20:01, Jorge I Velez <jorgeivanvelez@gmail.com > > >escribió: > > > > > Hola Eva, > > > > > > A continuacion un ejemplo: > > > > > > x <- rpois(20, 10) > > > x > > > x[x > 10] <- -20 > > > x > > > > > > Un saludo, > > > Jorge.- > > > > > > > > > 2012/6/12 Eva Prieto Castro <> > > > > > > > Hola, ¿qué tal? > > > > > > > > Fernando, me interesa mucho la sugerencia que haces a Javier, pero > no > > > > consigo llevarla a la práctica. > > > > > > > > Me da este error: > > > > > > > > > x[x[>3]] <- 3 > > > > Error: inesperado ''>'' en "x[x[>" > > > > > > > > Por favor, ¿podrías poner un ejemplo desde cero?. Gracias. > > > > > > > > Eva > > > > > > > > --- El mar, 12/6/12, Fernando Fernández <> escribió: > > > > > > > > De: Fernando Fernández <> > > > > Asunto: Re: [R-es] help: Bucles rápidos en R > > > > Para: "Javier Villacampa González" < > > javier.villacampa.gonzalez@gmail.com > > > > > > > > CC: r-help-es@r-project.org > > > > Fecha: martes, 12 de junio, 2012 15:19 > > > > > > > > Las funciones apply, lapply, sapply, tapply son tus amigas... También > > es > > > > bastante posible que estés haciendo tareas con bucles que se pueden > > > > escribir con instrucciones matriciales y subíndices. Del tipo: > > > > > > > > x[x[>3]]<-3 > > > > > > > > en lugar de: > > > > > > > > for(i in 1:length(x)){ > > > > if x[i]>3 then > > > > x[i]<-3 > > > > } > > > > > > > > Mi recomendacion es que antes de seguir programando te recorras los > > > > ejemplos de dos o tres manuales diferentes que suelen tener ejemplos > de > > > > como aprovechar estas instrucciones en R (Los que puedes encontrar en > > > CRAN > > > > deberían servirte). Merece la pena invertir algo de tiempo en > aprender > > a > > > > sacarles partido. > > > > > > > > El 12 de junio de 2012 14:32, Javier Villacampa González < > > > > javier.villacampa.gonzalez@gmail.com> escribió: > > > > > > > > > Buenas días a todos, > > > > > > > > > > una vez más os escribo para preguntaros una duda. Estoy haciendo > > bucles > > > > con > > > > > data frames, el problema es que al hacer bucles de esta manera el > > > sistema > > > > > se relentiza. He buscado por internet y en varias web te dicen que > > > evites > > > > > los bucles en la medida de lo posible y que intentes funcionar con > > c++ > > > > con > > > > > la librería Rccp > > http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. > > > > > > > > > > Mi preguta es > > > > > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje > > > > > 2 Alguna página con ejemplitos fáciles de Rccp. > > > > > > > > > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar > un > > > > > empujón os lo agradeceré. > > > > > > > > > > Un saludo y gracias por adelantado. > > > > > > > > > > [[alternative HTML version deleted]] > > > > > > > > > > > > > > > _______________________________________________ > > > > > R-help-es mailing list > > > > > R-help-es@r-project.org > > > > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > > > > > > > > > > > > > [[alternative HTML version deleted]] > > > > > > > > > > > > -----Adjunto en línea a continuación----- > > > > > > > > _______________________________________________ > > > > R-help-es mailing list > > > > R-help-es@r-project.org > > > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > > > [[alternative HTML version deleted]] > > > > > > > > > > > > _______________________________________________ > > > > R-help-es mailing list > > > > R-help-es@r-project.org > > > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > > > > > > > > > [[alternative HTML version deleted]] > > > > > > > > > _______________________________________________ > > > R-help-es mailing list > > > R-help-es@r-project.org > > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > > > > > [[alternative HTML version deleted]] > > > > > > _______________________________________________ > > R-help-es mailing list > > R-help-es@r-project.org > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >[[alternative HTML version deleted]]
Según Ripley sí es un loop disfrazado http://tolstoy.newcastle.edu.au/R/help/06/05/27255.html En el caso de una función paralizada es otra historia, también existen versiones parelizadas de loops. En todo caso es más eficiente vectorizar la operación en R si es posible. Vectorizando he disminuido el tiempo de ejecución de 8 horas a 10 minutos. Aunque hay veces que no se puede vectorizar y entonces hay que usar la versión paralelizable. Saludos Luciano El 14 de junio de 2012 12:01, Julio Alejandro Di Rienzo < dirienzo.julio@gmail.com> escribió:> Apply y sus variaciones son más que un loop disfrazado y existes sus > versiones paralelizables que son escensiales para manejar problemas grandes > como > applicar un modelo lineal mixtos complejo a una matriz de expresión génica > con 63k genes. > > > > Prof. Julio Di Rienzo > Estadística y Biometría > FCA- U.N. Córdoba > IBS-RARG President > http://sites.google.com/site/juliodirienzo > "Biometry, the active pursuit of biological > knowledge by quantitative methods." > (R.A. Fisher, 1948) > > > > 2012/6/14 Luciano Selzer <luciano.selzer@gmail.com> > >> ¡Ojo que apply y sus variaciones no son más que un loop disfrazado! >> Luciano >> >> >> El 12 de junio de 2012 18:52, Fernando Fernández < >> fernando.fernandez.gonzalez@gmail.com> escribió: >> >> > Efectivamente, quería decir eso, no se en qué estaba pensndo para poner >> el >> > segundo par de corchetes... >> > >> > Cuando veo a alguien escribir bucles for para hacer cosas así por no >> haber >> > dedicado unas horas a ojear algún manual de R... >> > >> > El 12 de junio de 2012 20:01, Jorge I Velez <jorgeivanvelez@gmail.com >> > >escribió: >> > >> > > Hola Eva, >> > > >> > > A continuacion un ejemplo: >> > > >> > > x <- rpois(20, 10) >> > > x >> > > x[x > 10] <- -20 >> > > x >> > > >> > > Un saludo, >> > > Jorge.- >> > > >> > > >> > > 2012/6/12 Eva Prieto Castro <> >> > > >> > > > Hola, ¿qué tal? >> > > > >> > > > Fernando, me interesa mucho la sugerencia que haces a Javier, pero >> no >> > > > consigo llevarla a la práctica. >> > > > >> > > > Me da este error: >> > > > >> > > > > x[x[>3]] <- 3 >> > > > Error: inesperado ''>'' en "x[x[>" >> > > > >> > > > Por favor, ¿podrías poner un ejemplo desde cero?. Gracias. >> > > > >> > > > Eva >> > > > >> > > > --- El mar, 12/6/12, Fernando Fernández <> escribió: >> > > > >> > > > De: Fernando Fernández <> >> > > > Asunto: Re: [R-es] help: Bucles rápidos en R >> > > > Para: "Javier Villacampa González" < >> > javier.villacampa.gonzalez@gmail.com >> > > > >> > > > CC: r-help-es@r-project.org >> > > > Fecha: martes, 12 de junio, 2012 15:19 >> > > > >> > > > Las funciones apply, lapply, sapply, tapply son tus amigas... >> También >> > es >> > > > bastante posible que estés haciendo tareas con bucles que se pueden >> > > > escribir con instrucciones matriciales y subíndices. Del tipo: >> > > > >> > > > x[x[>3]]<-3 >> > > > >> > > > en lugar de: >> > > > >> > > > for(i in 1:length(x)){ >> > > > if x[i]>3 then >> > > > x[i]<-3 >> > > > } >> > > > >> > > > Mi recomendacion es que antes de seguir programando te recorras los >> > > > ejemplos de dos o tres manuales diferentes que suelen tener >> ejemplos de >> > > > como aprovechar estas instrucciones en R (Los que puedes encontrar >> en >> > > CRAN >> > > > deberían servirte). Merece la pena invertir algo de tiempo en >> aprender >> > a >> > > > sacarles partido. >> > > > >> > > > El 12 de junio de 2012 14:32, Javier Villacampa González < >> > > > javier.villacampa.gonzalez@gmail.com> escribió: >> > > > >> > > > > Buenas días a todos, >> > > > > >> > > > > una vez más os escribo para preguntaros una duda. Estoy haciendo >> > bucles >> > > > con >> > > > > data frames, el problema es que al hacer bucles de esta manera el >> > > sistema >> > > > > se relentiza. He buscado por internet y en varias web te dicen que >> > > evites >> > > > > los bucles en la medida de lo posible y que intentes funcionar con >> > c++ >> > > > con >> > > > > la librería Rccp >> > http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. >> > > > > >> > > > > Mi preguta es >> > > > > 1 Se puede acelerar el proceso dentro de R si irme a otro lenguaje >> > > > > 2 Alguna página con ejemplitos fáciles de Rccp. >> > > > > >> > > > > Como ya veis tengo la duda a medio madurar, pero si me podeis dar >> un >> > > > > empujón os lo agradeceré. >> > > > > >> > > > > Un saludo y gracias por adelantado. >> > > > > >> > > > > [[alternative HTML version deleted]] >> > > > > >> > > > > >> > > > > _______________________________________________ >> > > > > R-help-es mailing list >> > > > > R-help-es@r-project.org >> > > > > https://stat.ethz.ch/mailman/listinfo/r-help-es >> > > > > >> > > > > >> > > > >> > > > [[alternative HTML version deleted]] >> > > > >> > > > >> > > > -----Adjunto en línea a continuación----- >> > > > >> > > > _______________________________________________ >> > > > R-help-es mailing list >> > > > R-help-es@r-project.org >> > > > https://stat.ethz.ch/mailman/listinfo/r-help-es >> > > > >> > > > [[alternative HTML version deleted]] >> > > > >> > > > >> > > > _______________________________________________ >> > > > R-help-es mailing list >> > > > R-help-es@r-project.org >> > > > https://stat.ethz.ch/mailman/listinfo/r-help-es >> > > > >> > > > >> > > >> > > [[alternative HTML version deleted]] >> > > >> > > >> > > _______________________________________________ >> > > R-help-es mailing list >> > > R-help-es@r-project.org >> > > https://stat.ethz.ch/mailman/listinfo/r-help-es >> > > >> > > >> > >> > [[alternative HTML version deleted]] >> > >> > >> > _______________________________________________ >> > R-help-es mailing list >> > R-help-es@r-project.org >> > https://stat.ethz.ch/mailman/listinfo/r-help-es >> > >> > >> >> [[alternative HTML version deleted]] >> >> >> _______________________________________________ >> R-help-es mailing list >> R-help-es@r-project.org >> https://stat.ethz.ch/mailman/listinfo/r-help-es >> >> >[[alternative HTML version deleted]]
Hola, Otro ejemplo de las mejoras posibles de la vectorización... http://fabiomarroni.wordpress.com/2012/06/03/r-and-theater/ De unos infernales bucles (16 minutos) a unos 3 segundos... ;-) Saludos, Carlos Ortega www.qualityexcellence.es El 14 de junio de 2012 19:07, Luciano Selzer <luciano.selzer@gmail.com>escribió:> Según Ripley sí es un loop disfrazado > http://tolstoy.newcastle.edu.au/R/help/06/05/27255.html > > En el caso de una función paralizada es otra historia, también existen > versiones parelizadas de loops. En todo caso es más eficiente vectorizar la > operación en R si es posible. Vectorizando he disminuido el tiempo de > ejecución de 8 horas a 10 minutos. > > Aunque hay veces que no se puede vectorizar y entonces hay que usar la > versión paralelizable. > > Saludos > Luciano > > > El 14 de junio de 2012 12:01, Julio Alejandro Di Rienzo < > dirienzo.julio@gmail.com> escribió: > > > Apply y sus variaciones son más que un loop disfrazado y existes sus > > versiones paralelizables que son escensiales para manejar problemas > grandes > > como > > applicar un modelo lineal mixtos complejo a una matriz de expresión > génica > > con 63k genes. > > > > > > > > Prof. Julio Di Rienzo > > Estadística y Biometría > > FCA- U.N. Córdoba > > IBS-RARG President > > http://sites.google.com/site/juliodirienzo > > "Biometry, the active pursuit of biological > > knowledge by quantitative methods." > > (R.A. Fisher, 1948) > > > > > > > > 2012/6/14 Luciano Selzer <luciano.selzer@gmail.com> > > > >> ¡Ojo que apply y sus variaciones no son más que un loop disfrazado! > >> Luciano > >> > >> > >> El 12 de junio de 2012 18:52, Fernando Fernández < > >> fernando.fernandez.gonzalez@gmail.com> escribió: > >> > >> > Efectivamente, quería decir eso, no se en qué estaba pensndo para > poner > >> el > >> > segundo par de corchetes... > >> > > >> > Cuando veo a alguien escribir bucles for para hacer cosas así por no > >> haber > >> > dedicado unas horas a ojear algún manual de R... > >> > > >> > El 12 de junio de 2012 20:01, Jorge I Velez <jorgeivanvelez@gmail.com > >> > >escribió: > >> > > >> > > Hola Eva, > >> > > > >> > > A continuacion un ejemplo: > >> > > > >> > > x <- rpois(20, 10) > >> > > x > >> > > x[x > 10] <- -20 > >> > > x > >> > > > >> > > Un saludo, > >> > > Jorge.- > >> > > > >> > > > >> > > 2012/6/12 Eva Prieto Castro <> > >> > > > >> > > > Hola, ¿qué tal? > >> > > > > >> > > > Fernando, me interesa mucho la sugerencia que haces a Javier, > pero > >> no > >> > > > consigo llevarla a la práctica. > >> > > > > >> > > > Me da este error: > >> > > > > >> > > > > x[x[>3]] <- 3 > >> > > > Error: inesperado ''>'' en "x[x[>" > >> > > > > >> > > > Por favor, ¿podrías poner un ejemplo desde cero?. Gracias. > >> > > > > >> > > > Eva > >> > > > > >> > > > --- El mar, 12/6/12, Fernando Fernández <> escribió: > >> > > > > >> > > > De: Fernando Fernández <> > >> > > > Asunto: Re: [R-es] help: Bucles rápidos en R > >> > > > Para: "Javier Villacampa González" < > >> > javier.villacampa.gonzalez@gmail.com > >> > > > > >> > > > CC: r-help-es@r-project.org > >> > > > Fecha: martes, 12 de junio, 2012 15:19 > >> > > > > >> > > > Las funciones apply, lapply, sapply, tapply son tus amigas... > >> También > >> > es > >> > > > bastante posible que estés haciendo tareas con bucles que se > pueden > >> > > > escribir con instrucciones matriciales y subíndices. Del tipo: > >> > > > > >> > > > x[x[>3]]<-3 > >> > > > > >> > > > en lugar de: > >> > > > > >> > > > for(i in 1:length(x)){ > >> > > > if x[i]>3 then > >> > > > x[i]<-3 > >> > > > } > >> > > > > >> > > > Mi recomendacion es que antes de seguir programando te recorras > los > >> > > > ejemplos de dos o tres manuales diferentes que suelen tener > >> ejemplos de > >> > > > como aprovechar estas instrucciones en R (Los que puedes encontrar > >> en > >> > > CRAN > >> > > > deberían servirte). Merece la pena invertir algo de tiempo en > >> aprender > >> > a > >> > > > sacarles partido. > >> > > > > >> > > > El 12 de junio de 2012 14:32, Javier Villacampa González < > >> > > > javier.villacampa.gonzalez@gmail.com> escribió: > >> > > > > >> > > > > Buenas días a todos, > >> > > > > > >> > > > > una vez más os escribo para preguntaros una duda. Estoy haciendo > >> > bucles > >> > > > con > >> > > > > data frames, el problema es que al hacer bucles de esta manera > el > >> > > sistema > >> > > > > se relentiza. He buscado por internet y en varias web te dicen > que > >> > > evites > >> > > > > los bucles en la medida de lo posible y que intentes funcionar > con > >> > c++ > >> > > > con > >> > > > > la librería Rccp > >> > http://cran.r-project.org/web/packages/Rcpp/Rcpp.pdf. > >> > > > > > >> > > > > Mi preguta es > >> > > > > 1 Se puede acelerar el proceso dentro de R si irme a otro > lenguaje > >> > > > > 2 Alguna página con ejemplitos fáciles de Rccp. > >> > > > > > >> > > > > Como ya veis tengo la duda a medio madurar, pero si me podeis > dar > >> un > >> > > > > empujón os lo agradeceré. > >> > > > > > >> > > > > Un saludo y gracias por adelantado. > >> > > > > > >> > > > > [[alternative HTML version deleted]] > >> > > > > > >> > > > > > >> > > > > _______________________________________________ > >> > > > > R-help-es mailing list > >> > > > > R-help-es@r-project.org > >> > > > > https://stat.ethz.ch/mailman/listinfo/r-help-es > >> > > > > > >> > > > > > >> > > > > >> > > > [[alternative HTML version deleted]] > >> > > > > >> > > > > >> > > > -----Adjunto en línea a continuación----- > >> > > > > >> > > > _______________________________________________ > >> > > > R-help-es mailing list > >> > > > R-help-es@r-project.org > >> > > > https://stat.ethz.ch/mailman/listinfo/r-help-es > >> > > > > >> > > > [[alternative HTML version deleted]] > >> > > > > >> > > > > >> > > > _______________________________________________ > >> > > > R-help-es mailing list > >> > > > R-help-es@r-project.org > >> > > > https://stat.ethz.ch/mailman/listinfo/r-help-es > >> > > > > >> > > > > >> > > > >> > > [[alternative HTML version deleted]] > >> > > > >> > > > >> > > _______________________________________________ > >> > > R-help-es mailing list > >> > > R-help-es@r-project.org > >> > > https://stat.ethz.ch/mailman/listinfo/r-help-es > >> > > > >> > > > >> > > >> > [[alternative HTML version deleted]] > >> > > >> > > >> > _______________________________________________ > >> > R-help-es mailing list > >> > R-help-es@r-project.org > >> > https://stat.ethz.ch/mailman/listinfo/r-help-es > >> > > >> > > >> > >> [[alternative HTML version deleted]] > >> > >> > >> _______________________________________________ > >> R-help-es mailing list > >> R-help-es@r-project.org > >> https://stat.ethz.ch/mailman/listinfo/r-help-es > >> > >> > > > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >-- Saludos, Carlos Ortega www.qualityexcellence.es [[alternative HTML version deleted]]