R help es - Sep 2021 - problema de tiempo de ejecución con una rutina dentro de un programa de R

ok Carlos, pongo un ejemplo con pocos registros a ver si puedo explicarlo
mejor:

Datos:
V0 V1 V2 V3 V4 V5 V6 V7 V8 V9 V10
1 63 1 1 145 A 233 1 2 3 0
2 67 1 4 160 A 286 0 2 2 3
3 67 2 4 120 B 229 0 2 2 2
4 37 1 3 130 C 250 0 0 3 0
5 41 1 2 130 C 204 0 2 1 0
6 56 2 2 120 A 236 0 0 1 0
7 62 1 4 140 B 268 0 2 3 2
8 57 2 4 120 C 354 0 0 1 0
9 63 2 4 130 A 254 0 2 2 1
10 53 1 4 140 B 203 1 2 3 0
11 57 2 4 140 B 192 0 0 2 0
12 56 1 2 140 A 294 0 2 2 0
13 56 2 3 130 C 256 1 2 2 1
14 44 2 2 120 B 263 0 0 1 0
15 52 2 3 172 B 199 1 0 1 0

tengo la matriz que sale de V5:
A
B
C

junto las filas de A con B, y obtengo el punto respecto de V2, y me da
(0.33, 0.67), puesto que V2 tiene dos valores, es un porcentaje en
definitiva
junto las filas de A con C, y se obtiene el punto (0.5, 0.5)
obtengo la distancia euclidea de dichos puntos sobre el punto definido,
supongamos (0.34, 066),  lo que significa que la menor distancia se obtiene
entre A y B, por lo tanto las filas que tienen A en V5 se cambia su valor a
C, y se obtiene la siguiente matriz, donde V5 ya no tiene la A
V0 V1 V2 V3 V4 V5 V6 V7 V8 V9 V10
1 63 1 1 145 C 233 1 2 3 0
2 67 1 4 160 C 286 0 2 2 3
3 67 2 4 120 B 229 0 2 2 2
4 37 1 3 130 C 250 0 0 3 0
5 41 1 2 130 C 204 0 2 1 0
6 56 2 2 120 C 236 0 0 1 0
7 62 1 4 140 B 268 0 2 3 2
8 57 2 4 120 C 354 0 0 1 0
9 63 2 4 130 C 254 0 2 2 1
10 53 1 4 140 B 203 1 2 3 0
11 57 2 4 140 B 192 0 0 2 0
12 56 1 2 140 C 294 0 2 2 0
13 56 2 3 130 C 256 1 2 2 1
14 44 2 2 120 B 263 0 0 1 0
15 52 2 3 172 B 199 1 0 1 0
en este ejemplo el while seria 2, es decir que se pararía puesto que solo
tengo dos valore en V5

Evidentemente cuando tengo 100.000 filas con 100 columnas y tengo la matriz
intermedia que he puesto en este ejemplo con letras de 2000 columnas,
puesto no veo como consumir menos tiempo de ejecucion.

espero que lo haya podido explicar mejor con este ejemplo.

gracias de antemano Carlos

El mié, 22 sept 2021 a las 17:48, Carlos Ortega (<cof en
qualityexcellence.es>)
escribió:
> Vaya me cuesta verlo... :-)...
>
> ¿Puedes poner un ejemplo con números con los diferentes vectores con los
> que partes y cómo vas rellenando esa matriz?
> Y cómo quedaría al final..
>
> Gracias!
> Carlos.
>
> El mié, 22 sept 2021 a las 16:01, Carlos Santos (<
> carlossantos.csm en gmail.com>) escribió:
>
>> jajajaja, perdón no te había entendido, lo siento
>>
>> a ver, de esta forma y para que sea fácil, supongamos esta matriz,
>> evidentemente el problema lo tengo cuando esta matriz es muy grande
claro.
>> G1
>> G2
>> G3
>> G4
>> G5
>> G6
>> G7
>> G8
>> G9
>> G10
>> El while lo puse porque quite el for que tenia al principio para no
poner
>> muchos FOR anidados, por lo tanto el while va a ejecutar el FOR
siguiente 7
>> veces
>>
>> El FOR lo que hace es ejecutarse 9 veces la primera vez, y agrupa los
>> registros de G1 con cada uno de los otros grupos individualmente,
calcula
>> el porcentaje de elementos de cada nuevo grupo respecto a una de las
>> variables del registro, por ejemplo supongamos que la variable tiene 2
>> valores, obtenemos un punto (X,Y) que representa el porcentaje de cada
>> valor que tiene la variable dentro de su nuevo grupo
>> Lo mismo para el resto de nuevos grupos, y se calcula la distancia
>> euclidea entre cada nuevo punto respecto de un punto predefinido.
>>
>> a continuación se haría tomando G2 con el resto descendente, y así
>> sucesivamente hasta que el while ejecute en este ejemplo 7 veces = 10-3
>>
>> Quizas asi este mas claro, Carlos
>>
>>
>>
>>
>>
>> El mié, 22 sept 2021 a las 15:43, Carlos Ortega (<
>> cof en qualityexcellence.es>) escribió:
>>
>>> Hola Carlos,
>>>
>>> Sí, si lo he entendido así.
>>>
>>> Lo que te propongo es que nos cuentes qué quieres hacer con esos
dos
>>> bucles o un bucle y un while. Porque a lo mejor se puede plantear
otra
>>> aproximación para actualizar cada elemento de la matriz.
>>>
>>> Gracias,
>>> Carlos.
>>>
>>> El mié, 22 sept 2021 a las 15:31, Carlos Santos (<
>>> carlossantos.csm en gmail.com>) escribió:
>>>
>>>> Gracias Carlos,
>>>>
>>>> Si, quizas no lo explique bien, lo fundamental y es donde se
tarda
>>>> mucho tiempod e cpu, es el bucle FOR, que tiene que recorrer
una matriz
>>>> desde 1 hasta totcluy, entendiendo que la variable totclu puede
ser por
>>>> ejemplo 10.000, lo que quiere decir que por cada fila tiene que
realizar el
>>>> calculo que he puesto en el FOR que tampoco es demasiado pero
logicamente
>>>> tiene que recorrer por ejemplo en este caso 10.000 columnas
>>>> A su vez el while tiene que hacerlo otras 10000 veces menos 3,
lo que
>>>> significa que el tiempo empleado hasta completar cada fila de
la matriz es
>>>> enorme
>>>>
>>>> no se si he podido explicarlo mejor, es por eso que entiendo
que el
>>>> bucle FOR es muy costoso, y aunque he puesto un while bien
podia ser un FOR
>>>> dentro de otro FOR, en donde el primero controla las filas y el
segundo las
>>>> columnas, pero no se como hacer que el tiempo de cpu sea lo
menor posible
>>>>
>>>> El mié, 22 sept 2021 a las 14:56, Carlos Ortega (<
>>>> cof en qualityexcellence.es>) escribió:
>>>>
>>>>> Hola,
>>>>>
>>>>> ¿Por qué no nos dices mejor el problema qué quieres
resolver con tus
>>>>> datos/matriz/matrices inicial?
>>>>> Seguramente podamos ver una forma alternativa a utilizar un
bucle...
>>>>>
>>>>> En cualquier caso, por si quieres ir viendo como correr ese
bucle en
>>>>> paralelo..:
>>>>>
>>>>>    -
>>>>>   
https://stackoverflow.com/questions/53054366/how-can-i-run-a-for-loop-in-parallel-in-r
>>>>>
>>>>> Saludos,
>>>>> Carlos Ortega
>>>>> www.qualityexcellence.es
>>>>>
>>>>> El mié, 22 sept 2021 a las 13:18, Carlos Santos (<
>>>>> carlossantos.csm en gmail.com>) escribió:
>>>>>
>>>>>> Hola a todos, familia de R
>>>>>>
>>>>>> Tengo un pequeño problema de tiempo de ejecución con
una rutina, a
>>>>>> ver si
>>>>>> me pueden echar una mano y ayudarme si es posible,
claro.
>>>>>>
>>>>>> La rutina es la siguiente:
>>>>>>
>>>>>> while(totclu != 3){
>>>>>>   matrizF <- matrix(0, nrow = 1, ncol = totclu)
>>>>>>   for (j in 1:totclu) {
>>>>>>     q1 <- c(which(data1$Clus.Multi.FAIRNESS ==
k2A$Var1[1]),
>>>>>>             which(data1$Clus.Multi.FAIRNESS ==
k2A$Var1[j]))
>>>>>>     q2 <-
nrow(as.data.frame(c(which(data1$Clus.Multi.FAIRNESS =>>>>>>
k2A$Var1[1]),
>>>>>>                               
which(data1$Clus.Multi.FAIRNESS =>>>>>> k2A$Var1[j]))))
>>>>>>     observado <- table(data1$VarFC[q1])/q2
>>>>>>     matrizF[i] <-
dist(rbind(observado,propuesto),method >>>>>>
"euclidean")
>>>>>>   }
>>>>>>   matrizF[1] <- 99
>>>>>>   min_observado <- which.min(matrizF)
>>>>>>   q4 <- which(data1$Clus.Multi.FAIRNESS ==
k2A$Var1[1])
>>>>>>   data1$Clus.Multi.FAIRNESS[q4] <-
>>>>>> as.character(k2A$Var1[min_observado])
>>>>>>   k2A$Freq[min_observado] <- k2A$Freq[min_observado]
+ k2A$Freq[1]
>>>>>>   k2A <-
>>>>>>
as.data.frame(table(as.character(data1$Clus.Multi.FAIRNESS))) %>%
>>>>>> arrange(Freq)
>>>>>>   totclu=nrow(k2A)
>>>>>> }
>>>>>>
>>>>>> El problema fundamental es que la matriz que aparece
como k2A es una
>>>>>> matriz
>>>>>> (nxn) lo que significa que puede ser muy grande, por
ejemplo
>>>>>> 1000x1000, y
>>>>>> el tiempo que tarda es enorme y no veo como disminuir
el tiempo de
>>>>>> ejecución del "for" que pienso que es lo mas
duro.
>>>>>>
>>>>>> No se si se puede poner como procesamiento en paralelo
en r, pero
>>>>>> tampoco
>>>>>> ser como ponerlo
>>>>>>
>>>>>> Si me pueden echar una mano, les estaré muy agradecido
>>>>>>
>>>>>> muchas gracias de antemano
>>>>>>
>>>>>> Carlos Santos
>>>>>>
>>>>>>         [[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
>>>>>>
>>>>>
>>>>>
>>>>> --
>>>>> Saludos,
>>>>> Carlos Ortega
>>>>> www.qualityexcellence.es
>>>>>
>>>>
>>>
>>> --
>>> Saludos,
>>> Carlos Ortega
>>> www.qualityexcellence.es
>>>
>>
>
> --
> Saludos,
> Carlos Ortega
> www.qualityexcellence.es
>
	[[alternative HTML version deleted]]

Perdón he puesto 2000 columnas pero quería decir 2000 filas

El mié., 22 sept. 2021 18:34, Carlos Santos <carlossantos.csm en
gmail.com>
escribió:
> ok Carlos, pongo un ejemplo con pocos registros a ver si puedo explicarlo
> mejor:
>
> Datos:
> V0 V1 V2 V3 V4 V5 V6 V7 V8 V9 V10
> 1 63 1 1 145 A 233 1 2 3 0
> 2 67 1 4 160 A 286 0 2 2 3
> 3 67 2 4 120 B 229 0 2 2 2
> 4 37 1 3 130 C 250 0 0 3 0
> 5 41 1 2 130 C 204 0 2 1 0
> 6 56 2 2 120 A 236 0 0 1 0
> 7 62 1 4 140 B 268 0 2 3 2
> 8 57 2 4 120 C 354 0 0 1 0
> 9 63 2 4 130 A 254 0 2 2 1
> 10 53 1 4 140 B 203 1 2 3 0
> 11 57 2 4 140 B 192 0 0 2 0
> 12 56 1 2 140 A 294 0 2 2 0
> 13 56 2 3 130 C 256 1 2 2 1
> 14 44 2 2 120 B 263 0 0 1 0
> 15 52 2 3 172 B 199 1 0 1 0
>
> tengo la matriz que sale de V5:
> A
> B
> C
>
> junto las filas de A con B, y obtengo el punto respecto de V2, y me da
> (0.33, 0.67), puesto que V2 tiene dos valores, es un porcentaje en
> definitiva
> junto las filas de A con C, y se obtiene el punto (0.5, 0.5)
> obtengo la distancia euclidea de dichos puntos sobre el punto definido,
> supongamos (0.34, 066),  lo que significa que la menor distancia se obtiene
> entre A y B, por lo tanto las filas que tienen A en V5 se cambia su valor a
> C, y se obtiene la siguiente matriz, donde V5 ya no tiene la A
> V0 V1 V2 V3 V4 V5 V6 V7 V8 V9 V10
> 1 63 1 1 145 C 233 1 2 3 0
> 2 67 1 4 160 C 286 0 2 2 3
> 3 67 2 4 120 B 229 0 2 2 2
> 4 37 1 3 130 C 250 0 0 3 0
> 5 41 1 2 130 C 204 0 2 1 0
> 6 56 2 2 120 C 236 0 0 1 0
> 7 62 1 4 140 B 268 0 2 3 2
> 8 57 2 4 120 C 354 0 0 1 0
> 9 63 2 4 130 C 254 0 2 2 1
> 10 53 1 4 140 B 203 1 2 3 0
> 11 57 2 4 140 B 192 0 0 2 0
> 12 56 1 2 140 C 294 0 2 2 0
> 13 56 2 3 130
>
	[[alternative HTML version deleted]]

Hola de nuevo, nadie tiene alguna idea que pueda ayudarme?, alguna
sugerencia posible? cualquier cosa me puede ayudar por favor.
muchas gracias





El mié, 22 sept 2021 a las 18:34, Carlos Santos (<carlossantos.csm en
gmail.com>)
escribió:
> ok Carlos, pongo un ejemplo con pocos registros a ver si puedo explicarlo
> mejor:
>
> Datos:
> V0 V1 V2 V3 V4 V5 V6 V7 V8 V9 V10
> 1 63 1 1 145 A 233 1 2 3 0
> 2 67 1 4 160 A 286 0 2 2 3
> 3 67 2 4 120 B 229 0 2 2 2
> 4 37 1 3 130 C 250 0 0 3 0
> 5 41 1 2 130 C 204 0 2 1 0
> 6 56 2 2 120 A 236 0 0 1 0
> 7 62 1 4 140 B 268 0 2 3 2
> 8 57 2 4 120 C 354 0 0 1 0
> 9 63 2 4 130 A 254 0 2 2 1
> 10 53 1 4 140 B 203 1 2 3 0
> 11 57 2 4 140 B 192 0 0 2 0
> 12 56 1 2 140 A 294 0 2 2 0
> 13 56 2 3 130 C 256 1 2 2 1
> 14 44 2 2 120 B 263 0 0 1 0
> 15 52 2 3 172 B 199 1 0 1 0
>
> tengo la matriz que sale de V5:
> A
> B
> C
>
> junto las filas de A con B, y obtengo el punto respecto de V2, y me da
> (0.33, 0.67), puesto que V2 tiene dos valores, es un porcentaje en
> definitiva
> junto las filas de A con C, y se obtiene el punto (0.5, 0.5)
> obtengo la distancia euclidea de dichos puntos sobre el punto definido,
> supongamos (0.34, 066),  lo que significa que la menor distancia se obtiene
> entre A y B, por lo tanto las filas que tienen A en V5 se cambia su valor a
> C, y se obtiene la siguiente matriz, donde V5 ya no tiene la A
> V0 V1 V2 V3 V4 V5 V6 V7 V8 V9 V10
> 1 63 1 1 145 C 233 1 2 3 0
> 2 67 1 4 160 C 286 0 2 2 3
> 3 67 2 4 120 B 229 0 2 2 2
> 4 37 1 3 130 C 250 0 0 3 0
> 5 41 1 2 130 C 204 0 2 1 0
> 6 56 2 2 120 C 236 0 0 1 0
> 7 62 1 4 140 B 268 0 2 3 2
> 8 57 2 4 120 C 354 0 0 1 0
> 9 63 2 4 130 C 254 0 2 2 1
> 10 53 1 4 140 B 203 1 2 3 0
> 11 57 2 4 140 B 192 0 0 2 0
> 12 56 1 2 140 C 294 0 2 2 0
> 13 56 2 3 130 C 256 1 2 2 1
> 14 44 2 2 120 B 263 0 0 1 0
> 15 52 2 3 172 B 199 1 0 1 0
> en este ejemplo el while seria 2, es decir que se pararía puesto que solo
> tengo dos valore en V5
>
> Evidentemente cuando tengo 100.000 filas con 100 columnas y tengo la
> matriz intermedia que he puesto en este ejemplo con letras de 2000 filas,
> puesto no veo como consumir menos tiempo de ejecucion.
>
> espero que lo haya podido explicar mejor con este ejemplo.
>
> gracias de antemano Carlos
>
> El mié, 22 sept 2021 a las 17:48, Carlos Ortega (<cof en
qualityexcellence.es>)
> escribió:
>
>> Vaya me cuesta verlo... :-)...
>>
>> ¿Puedes poner un ejemplo con números con los diferentes vectores con
los
>> que partes y cómo vas rellenando esa matriz?
>> Y cómo quedaría al final..
>>
>> Gracias!
>> Carlos.
>>
>> El mié, 22 sept 2021 a las 16:01, Carlos Santos (<
>> carlossantos.csm en gmail.com>) escribió:
>>
>>> jajajaja, perdón no te había entendido, lo siento
>>>
>>> a ver, de esta forma y para que sea fácil, supongamos esta matriz,
>>> evidentemente el problema lo tengo cuando esta matriz es muy grande
claro.
>>> G1
>>> G2
>>> G3
>>> G4
>>> G5
>>> G6
>>> G7
>>> G8
>>> G9
>>> G10
>>> El while lo puse porque quite el for que tenia al principio para no
>>> poner muchos FOR anidados, por lo tanto el while va a ejecutar el
FOR
>>> siguiente 7 veces
>>>
>>> El FOR lo que hace es ejecutarse 9 veces la primera vez, y agrupa
los
>>> registros de G1 con cada uno de los otros grupos individualmente,
calcula
>>> el porcentaje de elementos de cada nuevo grupo respecto a una de
las
>>> variables del registro, por ejemplo supongamos que la variable
tiene 2
>>> valores, obtenemos un punto (X,Y) que representa el porcentaje de
cada
>>> valor que tiene la variable dentro de su nuevo grupo
>>> Lo mismo para el resto de nuevos grupos, y se calcula la distancia
>>> euclidea entre cada nuevo punto respecto de un punto predefinido.
>>>
>>> a continuación se haría tomando G2 con el resto descendente, y así
>>> sucesivamente hasta que el while ejecute en este ejemplo 7 veces =
10-3
>>>
>>> Quizas asi este mas claro, Carlos
>>>
>>>
>>>
>>>
>>>
>>> El mié, 22 sept 2021 a las 15:43, Carlos Ortega (<
>>> cof en qualityexcellence.es>) escribió:
>>>
>>>> Hola Carlos,
>>>>
>>>> Sí, si lo he entendido así.
>>>>
>>>> Lo que te propongo es que nos cuentes qué quieres hacer con
esos dos
>>>> bucles o un bucle y un while. Porque a lo mejor se puede
plantear otra
>>>> aproximación para actualizar cada elemento de la matriz.
>>>>
>>>> Gracias,
>>>> Carlos.
>>>>
>>>> El mié, 22 sept 2021 a las 15:31, Carlos Santos (<
>>>> carlossantos.csm en gmail.com>) escribió:
>>>>
>>>>> Gracias Carlos,
>>>>>
>>>>> Si, quizas no lo explique bien, lo fundamental y es donde
se tarda
>>>>> mucho tiempod e cpu, es el bucle FOR, que tiene que
recorrer una matriz
>>>>> desde 1 hasta totcluy, entendiendo que la variable totclu
puede ser por
>>>>> ejemplo 10.000, lo que quiere decir que por cada fila tiene
que realizar el
>>>>> calculo que he puesto en el FOR que tampoco es demasiado
pero logicamente
>>>>> tiene que recorrer por ejemplo en este caso 10.000 columnas
>>>>> A su vez el while tiene que hacerlo otras 10000 veces menos
3, lo que
>>>>> significa que el tiempo empleado hasta completar cada fila
de la matriz es
>>>>> enorme
>>>>>
>>>>> no se si he podido explicarlo mejor, es por eso que
entiendo que el
>>>>> bucle FOR es muy costoso, y aunque he puesto un while bien
podia ser un FOR
>>>>> dentro de otro FOR, en donde el primero controla las filas
y el segundo las
>>>>> columnas, pero no se como hacer que el tiempo de cpu sea lo
menor posible
>>>>>
>>>>> El mié, 22 sept 2021 a las 14:56, Carlos Ortega (<
>>>>> cof en qualityexcellence.es>) escribió:
>>>>>
>>>>>> Hola,
>>>>>>
>>>>>> ¿Por qué no nos dices mejor el problema qué quieres
resolver con tus
>>>>>> datos/matriz/matrices inicial?
>>>>>> Seguramente podamos ver una forma alternativa a
utilizar un bucle...
>>>>>>
>>>>>> En cualquier caso, por si quieres ir viendo como correr
ese bucle en
>>>>>> paralelo..:
>>>>>>
>>>>>>    -
>>>>>>   
https://stackoverflow.com/questions/53054366/how-can-i-run-a-for-loop-in-parallel-in-r
>>>>>>
>>>>>> Saludos,
>>>>>> Carlos Ortega
>>>>>> www.qualityexcellence.es
>>>>>>
>>>>>> El mié, 22 sept 2021 a las 13:18, Carlos Santos (<
>>>>>> carlossantos.csm en gmail.com>) escribió:
>>>>>>
>>>>>>> Hola a todos, familia de R
>>>>>>>
>>>>>>> Tengo un pequeño problema de tiempo de ejecución
con una rutina, a
>>>>>>> ver si
>>>>>>> me pueden echar una mano y ayudarme si es posible,
claro.
>>>>>>>
>>>>>>> La rutina es la siguiente:
>>>>>>>
>>>>>>> while(totclu != 3){
>>>>>>>   matrizF <- matrix(0, nrow = 1, ncol = totclu)
>>>>>>>   for (j in 1:totclu) {
>>>>>>>     q1 <- c(which(data1$Clus.Multi.FAIRNESS ==
k2A$Var1[1]),
>>>>>>>             which(data1$Clus.Multi.FAIRNESS ==
k2A$Var1[j]))
>>>>>>>     q2 <-
nrow(as.data.frame(c(which(data1$Clus.Multi.FAIRNESS
=>>>>>>> k2A$Var1[1]),
>>>>>>>                               
which(data1$Clus.Multi.FAIRNESS =>>>>>>> k2A$Var1[j]))))
>>>>>>>     observado <- table(data1$VarFC[q1])/q2
>>>>>>>     matrizF[i] <-
dist(rbind(observado,propuesto),method >>>>>>>
"euclidean")
>>>>>>>   }
>>>>>>>   matrizF[1] <- 99
>>>>>>>   min_observado <- which.min(matrizF)
>>>>>>>   q4 <- which(data1$Clus.Multi.FAIRNESS ==
k2A$Var1[1])
>>>>>>>   data1$Clus.Multi.FAIRNESS[q4] <-
>>>>>>> as.character(k2A$Var1[min_observado])
>>>>>>>   k2A$Freq[min_observado] <-
k2A$Freq[min_observado] + k2A$Freq[1]
>>>>>>>   k2A <-
>>>>>>>
as.data.frame(table(as.character(data1$Clus.Multi.FAIRNESS))) %>%
>>>>>>> arrange(Freq)
>>>>>>>   totclu=nrow(k2A)
>>>>>>> }
>>>>>>>
>>>>>>> El problema fundamental es que la matriz que
aparece como k2A es una
>>>>>>> matriz
>>>>>>> (nxn) lo que significa que puede ser muy grande,
por ejemplo
>>>>>>> 1000x1000, y
>>>>>>> el tiempo que tarda es enorme y no veo como
disminuir el tiempo de
>>>>>>> ejecución del "for" que pienso que es lo
mas duro.
>>>>>>>
>>>>>>> No se si se puede poner como procesamiento en
paralelo en r, pero
>>>>>>> tampoco
>>>>>>> ser como ponerlo
>>>>>>>
>>>>>>> Si me pueden echar una mano, les estaré muy
agradecido
>>>>>>>
>>>>>>> muchas gracias de antemano
>>>>>>>
>>>>>>> Carlos Santos
>>>>>>>
>>>>>>>         [[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
>>>>>>>
>>>>>>
>>>>>>
>>>>>> --
>>>>>> Saludos,
>>>>>> Carlos Ortega
>>>>>> www.qualityexcellence.es
>>>>>>
>>>>>
>>>>
>>>> --
>>>> Saludos,
>>>> Carlos Ortega
>>>> www.qualityexcellence.es
>>>>
>>>
>>
>> --
>> Saludos,
>> Carlos Ortega
>> www.qualityexcellence.es
>>
>
	[[alternative HTML version deleted]]