thr3ads.net - R help es - [R-es] help: Bucles rápidos en R [Jun 2012]

If this information is useful, please help other people find it:
Share via:

Javier Villacampa González

2012-Jun-12 12:32 UTC

[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]]

Carlos Ortega

2012-Jun-12 12:55 UTC

head link

[R-es] help: Bucles rápidos en R

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

Luciano Selzer

2012-Jun-12 13:00 UTC

head link

[R-es] help: Bucles rápidos en R

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

Fernando Fernández

2012-Jun-12 13:19 UTC

head link

[R-es] help: Bucles rápidos en R

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

Marcuzzi, Javier Rubén

2012-Jun-12 13:33 UTC

head link

[R-es] help: Bucles rápidos en R

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

Javier Villacampa González

2012-Jun-12 14:06 UTC

head link

[R-es] help: Bucles rápidos en R

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

Javier Villacampa González

2012-Jun-12 14:19 UTC

head link

[R-es] help: Bucles rápidos en R

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

Fernando Fernández

2012-Jun-12 14:29 UTC

head link

[R-es] help: Bucles rápidos en R

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

Julio Alejandro Di Rienzo

2012-Jun-12 15:21 UTC

head link

[R-es] help: Bucles rápidos en R

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

Carlos Ortega

2012-Jun-12 15:55 UTC

head link

[R-es] help: Bucles rápidos en R

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

Jorge I Velez

2012-Jun-12 16:45 UTC

head link

[R-es] help: Bucles rápidos en R

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

Eva Prieto Castro

2012-Jun-12 16:47 UTC

head link

[R-es] help: Bucles rápidos en R

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

Jorge I Velez

2012-Jun-12 18:01 UTC

head link

[R-es] help: Bucles rápidos en R

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

Fernando Fernández

2012-Jun-12 21:52 UTC

head link

[R-es] help: Bucles rápidos en R

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

Luciano Selzer

2012-Jun-14 13:25 UTC

head link

[R-es] help: Bucles rápidos en R

¡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]]

Julio Alejandro Di Rienzo

2012-Jun-14 15:01 UTC

head link

[R-es] help: Bucles rápidos en R

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

Luciano Selzer

2012-Jun-14 17:07 UTC

head link

[R-es] help: Bucles rápidos en R

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

Carlos Ortega

2012-Jun-14 21:35 UTC

head link

[R-es] help: Bucles rápidos en R

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

R help es - Jun 2012 - help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R

[R-es] help: Bucles rápidos en R