thr3ads.net - R help es - [R-es] Corregir mismo ID para individuos diferentes en una serie temporal [Jan 2016]

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

Ruben Bermad

2016-Jan-25 17:11 UTC

[R-es] Corregir mismo ID para individuos diferentes en una serie temporal

Hola a todos, 
Quería preguntar si alguno sabe como puedo identificar registros con un mismo ID
en el tiempo, pero que hacer referencia a objetos o individuos diferentes.
En mi caso en particular estoy estudiando un animal que tiene una vida media
cercana 2 años, y tengo una serie longitudinal de 25 años. El problema es que
durante el muestreo en algunos casos durante la recoleccion de los datos, se
repitieron los nombres de los individuos porque se asumen que si ha pasado 10
años no puede ser el mismo individuo. Y el problema que yo tengo es que no se
como detectar de manera automática este tipo de errores.
Había pensado era en registrar la primera aparición de cada nombre (e.g indiv_1,
y ver el tiempo que ha pasado en comparación con el resto de registros para ese
mismo individuo, y en el caso que fuera superior (por ejemplo a 36 meses para
estar totalmente seguros), que ese individuo que había sido registrado como
"indiv_1" sea renombrado (e.g. indiv_150), y cambiar todos los
siguientes registros de indiv_1 a indiv_150.
Esto parece sencillo, pero lo complicado al revisar todos los casos nombrados
ahora como indiv_150 ya que es posible que el nombre indiv_1 haya sido usado
para varios individuos diferentes a lo largo de la serie (e.g. en el año 1, 10 y
20). Entonces lo que había pensado es hacer un bucle para cada individuo, pero
no consigo que cada vez que cambia el nombre de un individuo (e.g. en el año 10)
capture la nueva fecha para determinar si los siguientes nombres hacen
referencia al mismo individuo u a otro muy posterior en el tiempo (e.g. año 20).
Esta pregunta la pregunte hace tiempo en
stackoverflowhttp://stackoverflow.com/questions/32310520/identify-objects-with-repeated-measures-and-with-the-same-id-between-years,
pero no obtuve una respuesta que solucionara el problema, y los posteriores
intentos que he estado haciendo tampoco han sido muy buenos que se digan (os lo
copio al final del mensaje).
Por ello os quería preguntar si alguno sabe como puedo ir registrando y
cambiando los IDs a lo largo del tiempo.
Muchas gracias por adelantado, Un cordial saludo, Rubén
Codigo usadodatabase es la base de datos con la serie temporalID_original es el
identificado original que tiene cada individuoMonth_Capt es la variable que me
indica en que momento fue capturado cada individuo y por tanto si es posible o
no que el individuo sea el mismo a lo largo del tiempo.
newID <-sapply(unique(database$ID_original), function(x)
c(0,cumsum(diff(database$Month_Capt[database$ID_original==x]))%%48))names(newID)<-(unique(database$ID_original))
new_df<-data.frame(database$ID_original,database$Month_Capt,IDcond=NA,new_ID=NA)for(i
in unique(database$ID_original)){ 
new_df[new_df[,1]==i,3]<-newID[[which(unique(database$ID_original)==i)]]}ltrs<-c(LETTERS,apply(combn(LETTERS,2,simplify
= T),2,function(x) paste(x,sep = "",collapse = "")))
letterwrap <- function(n, depth = 1) {  args <- lapply(1:depth, FUN =
function(x) return(LETTERS))  x <- do.call(expand.grid, args = list(args,
stringsAsFactors = F))  x <- x[, rev(names(x)), drop = F]  x <-
do.call(paste0, x)  if (n <= length(x)) return(x[1:n])  return(c(x,
letterwrap(n - length(x), depth = depth + 1)))}
ltrs <- letterwrap(nrow(database)) # Create as many letters as unique IDs

ltrn<-0for(i in 1:nrow(new_df)){  if(new_df[i,3]==0)
{ltrn<-ltrn+1;new_df[i,4]<-ltrs[ltrn]}  else
{ind<-which(new_df[,1]==new_df[i,1])        ind<-ind[ind<i]       
new_df[i,4]<-tail(new_df[ind,4],1)}}
 		 	   		  
	[[alternative HTML version deleted]]

Carlos Ortega

2016-Jan-25 22:09 UTC

head link

[R-es] Corregir mismo ID para individuos diferentes en una serie temporal

Hola,

Creo que el código que te adjunto hace lo que pides.
Los nuevos ids los he generado con números no con letras, me resulta más
fácil tratar el problema así.


#----------------------
ID <- c(1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6,
1, 2, 6, 8, 12, 7, 15, 16, 17, 18, 19, 20, 1, 21, 22, 19 )
Year <- c (1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6)
df <- data.frame (ID, Year)
df

ID <- c(1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6,
1, 2, 6, 8, 12, 7, 15, 16, 17, 18, 19, 20, 1, 21, 22, 19 )
Year <- c (1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 1, 6, 6, 6)
new_ID <- c("A", "B", "C", "D",
"E", "F", "G", "A", "B",
"C", "H", "I",
"J", "K", "L", "M", "N",
"O", "P", "Q", "R", "M",
"N", "Q", "S", "L", "T",
"U", "V", "W", "X", "Y",
"Z", "CC", "AA", "BB", "Y")
ref_df <- data.frame (ID, Year, new_ID)
ref_df

rep_val <- rep(0, nrow(df))
new_df <- data.frame(ID=rep_val, Year=rep_val, newID=rep_val,
hmyears=rep_val )
for(i in 1:nrow(df)) { #Cero
  if(i==1) {
    new_df$ID[i] <- df$ID[i]
    new_df$Year[i] <- df$Year[i]
    new_df$newID[i] <- df$ID[i]
    new_df$hmyears[i] <- 1
  } else {                                #Uno
    coin <- which(df$ID[i]==df$ID[1:(i-1)])
    print(coin)
    if(length(coin) < 1 ) {
      new_df$ID[i] <- df$ID[i]
      new_df$Year[i] <- df$Year[i]
      if(length(which(df$ID[i]==new_df$newID)) < 1) {new_df$newID[i] <-
df$ID[i]} else {new_df$newID[i] <- max(new_df$newID)+1}
      new_df$hmyears[i] <- 1
    } else {                              #Dos
      if( new_df$hmyears[max(coin)] < 2 ) {
        new_df$ID[i] <- df$ID[i]
        new_df$Year[i] <- df$Year[i]
        new_df$newID[i] <- new_df$newID[max(coin)]
        new_df$hmyears[i] <- new_df$hmyears[max(coin)] + 1
      } else {                            #Tres
        new_df$ID[i] <- df$ID[i]
        new_df$Year[i] <- df$Year[i]
        new_df$newID[i] <- max(new_df$newID) + 1
        new_df$hmyears[i] <- 1
      } #Tres

    } #Dos
  } #Uno
} #Cero
new_df

#----------------------

Saludos,
Carlos Ortega
www.qualityexcellence.es


El 25 de enero de 2016, 18:11, Ruben Bermad <ruben_bm en hotmail.com>
escribió:
> Hola a todos,
> Quería preguntar si alguno sabe como puedo identificar registros con un
> mismo ID en el tiempo, pero que hacer referencia a objetos o individuos
> diferentes.
> En mi caso en particular estoy estudiando un animal que tiene una vida
> media cercana 2 años, y tengo una serie longitudinal de 25 años. El
> problema es que durante el muestreo en algunos casos durante la recoleccion
> de los datos, se repitieron los nombres de los individuos porque se asumen
> que si ha pasado 10 años no puede ser el mismo individuo. Y el problema que
> yo tengo es que no se como detectar de manera automática este tipo de
> errores.
> Había pensado era en registrar la primera aparición de cada nombre (e.g
> indiv_1, y ver el tiempo que ha pasado en comparación con el resto de
> registros para ese mismo individuo, y en el caso que fuera superior (por
> ejemplo a 36 meses para estar totalmente seguros), que ese individuo que
> había sido registrado como "indiv_1" sea renombrado (e.g.
indiv_150), y
> cambiar todos los siguientes registros de indiv_1 a indiv_150.
> Esto parece sencillo, pero lo complicado al revisar todos los casos
> nombrados ahora como indiv_150 ya que es posible que el nombre indiv_1 haya
> sido usado para varios individuos diferentes a lo largo de la serie (e.g.
> en el año 1, 10 y 20). Entonces lo que había pensado es hacer un bucle para
> cada individuo, pero no consigo que cada vez que cambia el nombre de un
> individuo (e.g. en el año 10) capture la nueva fecha para determinar si los
> siguientes nombres hacen referencia al mismo individuo u a otro muy
> posterior en el tiempo (e.g. año 20).
> Esta pregunta la pregunte hace tiempo en stackoverflowhttp://
>
stackoverflow.com/questions/32310520/identify-objects-with-repeated-measures-and-with-the-same-id-between-years,
> pero no obtuve una respuesta que solucionara el problema, y los posteriores
> intentos que he estado haciendo tampoco han sido muy buenos que se digan
> (os lo copio al final del mensaje).
> Por ello os quería preguntar si alguno sabe como puedo ir registrando y
> cambiando los IDs a lo largo del tiempo.
> Muchas gracias por adelantado, Un cordial saludo, Rubén
> Codigo usadodatabase es la base de datos con la serie temporalID_original
> es el identificado original que tiene cada individuoMonth_Capt es la
> variable que me indica en que momento fue capturado cada individuo y por
> tanto si es posible o no que el individuo sea el mismo a lo largo del
> tiempo.
> newID <-sapply(unique(database$ID_original), function(x)
>
c(0,cumsum(diff(database$Month_Capt[database$ID_original==x]))%%48))names(newID)<-(unique(database$ID_original))
>
new_df<-data.frame(database$ID_original,database$Month_Capt,IDcond=NA,new_ID=NA)for(i
> in unique(database$ID_original)){
>
new_df[new_df[,1]==i,3]<-newID[[which(unique(database$ID_original)==i)]]}ltrs<-c(LETTERS,apply(combn(LETTERS,2,simplify
> = T),2,function(x) paste(x,sep = "",collapse = "")))
> letterwrap <- function(n, depth = 1) {  args <- lapply(1:depth, FUN
> function(x) return(LETTERS))  x <- do.call(expand.grid, args =
list(args,
> stringsAsFactors = F))  x <- x[, rev(names(x)), drop = F]  x <-
> do.call(paste0, x)  if (n <= length(x)) return(x[1:n])  return(c(x,
> letterwrap(n - length(x), depth = depth + 1)))}
> ltrs <- letterwrap(nrow(database)) # Create as many letters as unique
IDs
>
> ltrn<-0for(i in 1:nrow(new_df)){  if(new_df[i,3]==0)
> {ltrn<-ltrn+1;new_df[i,4]<-ltrs[ltrn]}  else
> {ind<-which(new_df[,1]==new_df[i,1])        ind<-ind[ind<i]
> new_df[i,4]<-tail(new_df[ind,4],1)}}
>
>         [[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

	[[alternative HTML version deleted]]

Javier Marcuzzi

2016-Jan-25 23:33 UTC

head link

[R-es] Corregir mismo ID para individuos diferentes en una serietemporal

Estimados

Creo que ese problema es muy común, almacenar mal la información y darse cuenta
al tiempo de análisis. Es el problema que yo encontré cuándo comencé a ser
profesional y dejar mis tiempos de estudiante cuándo los ejemplos andan.

Mi respuesta va por dos lados:

El primero, no comprendo el caso de 

1    1     CC

En el ejemplo de Carlos Ortega,  en la tabla ref_df línea 34.

El segundo lado, ¿Qué pasa por ejemplo trabajando con una base de datos como
puede ser sqldf o cualquier herramienta y usar una clave compuesta?
CREATE TABLE something (
  column1, 
  column2, 
  column3, 
  PRIMARY KEY (column1, column2)
);
Pero si los individuos tienen una vida media de 2 años, más algo de seguridad,
¿hay alguno que viva 3 años?, ¿Se pueden borrar esos registros por estar mal?

Javier Rubén Marcuzzi


De: Carlos Ortega
Enviado: lunes, 25 de enero de 2016 19:09
Para: Ruben Bermad
CC: r-help-es en r-project.org
Asunto: Re: [R-es] Corregir mismo ID para individuos diferentes en una
serietemporal

Hola,

Creo que el código que te adjunto hace lo que pides.
Los nuevos ids los he generado con números no con letras, me resulta más
fácil tratar el problema así.


#----------------------
ID <- c(1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6,
1, 2, 6, 8, 12, 7, 15, 16, 17, 18, 19, 20, 1, 21, 22, 19 )
Year <- c (1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6)
df <- data.frame (ID, Year)
df

ID <- c(1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6,
1, 2, 6, 8, 12, 7, 15, 16, 17, 18, 19, 20, 1, 21, 22, 19 )
Year <- c (1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 1, 6, 6, 6)
new_ID <- c("A", "B", "C", "D",
"E", "F", "G", "A", "B",
"C", "H", "I",
"J", "K", "L", "M", "N",
"O", "P", "Q", "R", "M",
"N", "Q", "S", "L", "T",
"U", "V", "W", "X", "Y",
"Z", "CC", "AA", "BB", "Y")
ref_df <- data.frame (ID, Year, new_ID)
ref_df

rep_val <- rep(0, nrow(df))
new_df <- data.frame(ID=rep_val, Year=rep_val, newID=rep_val,
hmyears=rep_val )
for(i in 1:nrow(df)) { #Cero
  if(i==1) {
    new_df$ID[i] <- df$ID[i]
    new_df$Year[i] <- df$Year[i]
    new_df$newID[i] <- df$ID[i]
    new_df$hmyears[i] <- 1
  } else {                                #Uno
    coin <- which(df$ID[i]==df$ID[1:(i-1)])
    print(coin)
    if(length(coin) < 1 ) {
      new_df$ID[i] <- df$ID[i]
      new_df$Year[i] <- df$Year[i]
      if(length(which(df$ID[i]==new_df$newID)) < 1) {new_df$newID[i] <-
df$ID[i]} else {new_df$newID[i] <- max(new_df$newID)+1}
      new_df$hmyears[i] <- 1
    } else {                              #Dos
      if( new_df$hmyears[max(coin)] < 2 ) {
        new_df$ID[i] <- df$ID[i]
        new_df$Year[i] <- df$Year[i]
        new_df$newID[i] <- new_df$newID[max(coin)]
        new_df$hmyears[i] <- new_df$hmyears[max(coin)] + 1
      } else {                            #Tres
        new_df$ID[i] <- df$ID[i]
        new_df$Year[i] <- df$Year[i]
        new_df$newID[i] <- max(new_df$newID) + 1
        new_df$hmyears[i] <- 1
      } #Tres

    } #Dos
  } #Uno
} #Cero
new_df

#----------------------

Saludos,
Carlos Ortega
www.qualityexcellence.es


El 25 de enero de 2016, 18:11, Ruben Bermad <ruben_bm en hotmail.com>
escribió:
> Hola a todos,
> Quería preguntar si alguno sabe como puedo identificar registros con un
> mismo ID en el tiempo, pero que hacer referencia a objetos o individuos
> diferentes.
> En mi caso en particular estoy estudiando un animal que tiene una vida
> media cercana 2 años, y tengo una serie longitudinal de 25 años. El
> problema es que durante el muestreo en algunos casos durante la recoleccion
> de los datos, se repitieron los nombres de los individuos porque se asumen
> que si ha pasado 10 años no puede ser el mismo individuo. Y el problema que
> yo tengo es que no se como detectar de manera automática este tipo de
> errores.
> Había pensado era en registrar la primera aparición de cada nombre (e.g
> indiv_1, y ver el tiempo que ha pasado en comparación con el resto de
> registros para ese mismo individuo, y en el caso que fuera superior (por
> ejemplo a 36 meses para estar totalmente seguros), que ese individuo que
> había sido registrado como "indiv_1" sea renombrado (e.g.
indiv_150), y
> cambiar todos los siguientes registros de indiv_1 a indiv_150.
> Esto parece sencillo, pero lo complicado al revisar todos los casos
> nombrados ahora como indiv_150 ya que es posible que el nombre indiv_1 haya
> sido usado para varios individuos diferentes a lo largo de la serie (e.g.
> en el año 1, 10 y 20). Entonces lo que había pensado es hacer un bucle para
> cada individuo, pero no consigo que cada vez que cambia el nombre de un
> individuo (e.g. en el año 10) capture la nueva fecha para determinar si los
> siguientes nombres hacen referencia al mismo individuo u a otro muy
> posterior en el tiempo (e.g. año 20).
> Esta pregunta la pregunte hace tiempo en stackoverflowhttp://
>
stackoverflow.com/questions/32310520/identify-objects-with-repeated-measures-and-with-the-same-id-between-years,
> pero no obtuve una respuesta que solucionara el problema, y los posteriores
> intentos que he estado haciendo tampoco han sido muy buenos que se digan
> (os lo copio al final del mensaje).
> Por ello os quería preguntar si alguno sabe como puedo ir registrando y
> cambiando los IDs a lo largo del tiempo.
> Muchas gracias por adelantado, Un cordial saludo, Rubén
> Codigo usadodatabase es la base de datos con la serie temporalID_original
> es el identificado original que tiene cada individuoMonth_Capt es la
> variable que me indica en que momento fue capturado cada individuo y por
> tanto si es posible o no que el individuo sea el mismo a lo largo del
> tiempo.
> newID <-sapply(unique(database$ID_original), function(x)
>
c(0,cumsum(diff(database$Month_Capt[database$ID_original==x]))%%48))names(newID)<-(unique(database$ID_original))
>
new_df<-data.frame(database$ID_original,database$Month_Capt,IDcond=NA,new_ID=NA)for(i
> in unique(database$ID_original)){
>
new_df[new_df[,1]==i,3]<-newID[[which(unique(database$ID_original)==i)]]}ltrs<-c(LETTERS,apply(combn(LETTERS,2,simplify
> = T),2,function(x) paste(x,sep = "",collapse = "")))
> letterwrap <- function(n, depth = 1) {  args <- lapply(1:depth, FUN
> function(x) return(LETTERS))  x <- do.call(expand.grid, args =
list(args,
> stringsAsFactors = F))  x <- x[, rev(names(x)), drop = F]  x <-
> do.call(paste0, x)  if (n <= length(x)) return(x[1:n])  return(c(x,
> letterwrap(n - length(x), depth = depth + 1)))}
> ltrs <- letterwrap(nrow(database)) # Create as many letters as unique
IDs
>
> ltrn<-0for(i in 1:nrow(new_df)){  if(new_df[i,3]==0)
> {ltrn<-ltrn+1;new_df[i,4]<-ltrs[ltrn]}  else
> {ind<-which(new_df[,1]==new_df[i,1])        ind<-ind[ind<i]
> new_df[i,4]<-tail(new_df[ind,4],1)}}
>
>         [[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

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


	[[alternative HTML version deleted]]

Ruben Bermad

2016-Jan-26 11:04 UTC

head link

[R-es] Corregir mismo ID para individuos diferentes en una serie temporal

Hola, 
 
Antes de nada, muchas gracias por tu ayuda. 
 
El código se ha acercado bastante, pero no termina de funcionar porque considera
cada captura de un individuo como años consecutivos aunque haya pasado más
tiempo entre ellos.
 
Por ejemplo el individuo 4 es capturado por primera vez el año 1 y por segunda
vez el año 3, por lo que debería de ser renombrado ya que en este ejemplo en
concreto asumimos que la vida maxima son 2 años desde su primera aparición. Pero
el script considera que es el mismo individuo porque es la segunda vez un
individuo con ese nombre es capturado, sin tener en cuenta el tiempo que ha
pasado entre la segunda captura y la primera.
 
Yo habia pensado en salvar en una columna el tiempo de la primera aparicion y
cada vez que aparezca un individuo con el mismo nombre restarle el tiempo del
que aparecio por primera vez con ese nombre. De esa manera queda registrado el
tiempo que ha pasado entre ambas apariciones, y si es superior al tiempo que
consideramos imposible habria que renombrarlo.
 
Lo que no se hacer es como repetir el proceso las veces necesarias, suponiendo
que puede haber un tercer individuo con el mismo nombre (e.g. el individuo 1 en
el año 5 que coge como referencia la primera aparicion del individuo 1
renombrado como individuo 13).
 
Muchas gracias.
Un cordial saludo, 
Rubén

 
Date: Mon, 25 Jan 2016 23:09:13 +0100
Subject: Re: [R-es] Corregir mismo ID para individuos diferentes en una serie
temporal
From: cof en qualityexcellence.es
To: ruben_bm en hotmail.com
CC: r-help-es en r-project.org

Hola,
Creo que el código que te adjunto hace lo que pides.Los nuevos ids los he
generado con números no con letras, me resulta más fácil tratar el problema así.

#----------------------ID <- c(1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 8, 9, 10, 11,
12, 1, 2, 3, 4, 5, 6, 1, 2, 6, 8, 12, 7, 15, 16, 17, 18, 19, 20, 1, 21, 22, 19
)Year <- c (1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4,
4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6)df <- data.frame (ID, Year)df
ID <- c(1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6, 1,
2, 6, 8, 12, 7, 15, 16, 17, 18, 19, 20, 1, 21, 22, 19 )Year <- c (1, 1, 1, 1,
1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5,
5, 5, 1, 6, 6, 6)new_ID <- c("A", "B", "C",
"D", "E", "F", "G", "A",
"B", "C", "H", "I", "J",
"K", "L", "M", "N", "O",
"P", "Q", "R", "M", "N",
"Q", "S", "L", "T", "U",
"V", "W", "X", "Y", "Z",
"CC", "AA", "BB", "Y")ref_df <-
data.frame (ID, Year, new_ID)ref_df
rep_val <- rep(0, nrow(df))new_df <- data.frame(ID=rep_val, Year=rep_val,
newID=rep_val, hmyears=rep_val )for(i in 1:nrow(df)) { #Cero  if(i==1) {   
new_df$ID[i] <- df$ID[i]    new_df$Year[i] <- df$Year[i]   
new_df$newID[i] <- df$ID[i]    new_df$hmyears[i] <- 1  } else {           
#Uno     coin <- which(df$ID[i]==df$ID[1:(i-1)])    print(coin)   
if(length(coin) < 1 ) {      new_df$ID[i] <- df$ID[i]      new_df$Year[i]
<- df$Year[i]      if(length(which(df$ID[i]==new_df$newID)) < 1)
{new_df$newID[i] <- df$ID[i]} else {new_df$newID[i] <-
max(new_df$newID)+1}      new_df$hmyears[i] <- 1    } else {                 
#Dos       if( new_df$hmyears[max(coin)] < 2 ) {        new_df$ID[i] <-
df$ID[i]        new_df$Year[i] <- df$Year[i]        new_df$newID[i] <-
new_df$newID[max(coin)]        new_df$hmyears[i] <- new_df$hmyears[max(coin)]
+ 1      } else {                            #Tres        new_df$ID[i] <-
df$ID[i]        new_df$Year[i] <- df$Year[i]        new_df$newID[i] <-
max(new_df$newID) + 1        new_df$hmyears[i] <- 1      } #Tres          }
#Dos  } #Uno} #Ceronew_df
#----------------------
Saludos,Carlos Ortegawww.qualityexcellence.es

El 25 de enero de 2016, 18:11, Ruben Bermad <ruben_bm en hotmail.com>
escribió:
Hola a todos,

Quería preguntar si alguno sabe como puedo identificar registros con un mismo ID
en el tiempo, pero que hacer referencia a objetos o individuos diferentes.

En mi caso en particular estoy estudiando un animal que tiene una vida media
cercana 2 años, y tengo una serie longitudinal de 25 años. El problema es que
durante el muestreo en algunos casos durante la recoleccion de los datos, se
repitieron los nombres de los individuos porque se asumen que si ha pasado 10
años no puede ser el mismo individuo. Y el problema que yo tengo es que no se
como detectar de manera automática este tipo de errores.

Había pensado era en registrar la primera aparición de cada nombre (e.g indiv_1,
y ver el tiempo que ha pasado en comparación con el resto de registros para ese
mismo individuo, y en el caso que fuera superior (por ejemplo a 36 meses para
estar totalmente seguros), que ese individuo que había sido registrado como
"indiv_1" sea renombrado (e.g. indiv_150), y cambiar todos los
siguientes registros de indiv_1 a indiv_150.

Esto parece sencillo, pero lo complicado al revisar todos los casos nombrados
ahora como indiv_150 ya que es posible que el nombre indiv_1 haya sido usado
para varios individuos diferentes a lo largo de la serie (e.g. en el año 1, 10 y
20). Entonces lo que había pensado es hacer un bucle para cada individuo, pero
no consigo que cada vez que cambia el nombre de un individuo (e.g. en el año 10)
capture la nueva fecha para determinar si los siguientes nombres hacen
referencia al mismo individuo u a otro muy posterior en el tiempo (e.g. año 20).

Esta pregunta la pregunte hace tiempo en
stackoverflowhttp://stackoverflow.com/questions/32310520/identify-objects-with-repeated-measures-and-with-the-same-id-between-years,
pero no obtuve una respuesta que solucionara el problema, y los posteriores
intentos que he estado haciendo tampoco han sido muy buenos que se digan (os lo
copio al final del mensaje).

Por ello os quería preguntar si alguno sabe como puedo ir registrando y
cambiando los IDs a lo largo del tiempo.

Muchas gracias por adelantado, Un cordial saludo, Rubén

Codigo usadodatabase es la base de datos con la serie temporalID_original es el
identificado original que tiene cada individuoMonth_Capt es la variable que me
indica en que momento fue capturado cada individuo y por tanto si es posible o
no que el individuo sea el mismo a lo largo del tiempo.

newID <-sapply(unique(database$ID_original), function(x)
c(0,cumsum(diff(database$Month_Capt[database$ID_original==x]))%%48))names(newID)<-(unique(database$ID_original))

new_df<-data.frame(database$ID_original,database$Month_Capt,IDcond=NA,new_ID=NA)for(i
in unique(database$ID_original)){ 
new_df[new_df[,1]==i,3]<-newID[[which(unique(database$ID_original)==i)]]}ltrs<-c(LETTERS,apply(combn(LETTERS,2,simplify
= T),2,function(x) paste(x,sep = "",collapse = "")))

letterwrap <- function(n, depth = 1) {  args <- lapply(1:depth, FUN =
function(x) return(LETTERS))  x <- do.call(expand.grid, args = list(args,
stringsAsFactors = F))  x <- x[, rev(names(x)), drop = F]  x <-
do.call(paste0, x)  if (n <= length(x)) return(x[1:n])  return(c(x,
letterwrap(n - length(x), depth = depth + 1)))}

ltrs <- letterwrap(nrow(database)) # Create as many letters as unique IDs



ltrn<-0for(i in 1:nrow(new_df)){  if(new_df[i,3]==0)
{ltrn<-ltrn+1;new_df[i,4]<-ltrs[ltrn]}  else
{ind<-which(new_df[,1]==new_df[i,1])        ind<-ind[ind<i]       
new_df[i,4]<-tail(new_df[ind,4],1)}}



        [[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
 		 	   		  
	[[alternative HTML version deleted]]

Fernando Macedo

2016-Jan-26 15:07 UTC

head link

[R-es] Corregir mismo ID para individuos diferentes en una serie temporal

Buenas, si tienes la fecha de nacimiento una salida sencilla para salir 
del paso es concatenar el ID con el año de nacimiento.

Saludos

Fernando Macedo

El 25/01/16 a las 14:11, Ruben Bermad escribió:> Hola a todos,
> Quer?a preguntar si alguno sabe como puedo identificar registros con un
mismo ID en el tiempo, pero que hacer referencia a objetos o individuos
diferentes.
> En mi caso en particular estoy estudiando un animal que tiene una vida
media cercana 2 a?os, y tengo una serie longitudinal de 25 a?os. El problema es
que durante el muestreo en algunos casos durante la recoleccion de los datos, se
repitieron los nombres de los individuos porque se asumen que si ha pasado 10
a?os no puede ser el mismo individuo. Y el problema que yo tengo es que no se
como detectar de manera autom?tica este tipo de errores.
> Hab?a pensado era en registrar la primera aparici?n de cada nombre (e.g
indiv_1, y ver el tiempo que ha pasado en comparaci?n con el resto de registros
para ese mismo individuo, y en el caso que fuera superior (por ejemplo a 36
meses para estar totalmente seguros), que ese individuo que hab?a sido
registrado como "indiv_1" sea renombrado (e.g. indiv_150), y cambiar
todos los siguientes registros de indiv_1 a indiv_150.
> Esto parece sencillo, pero lo complicado al revisar todos los casos
nombrados ahora como indiv_150 ya que es posible que el nombre indiv_1 haya sido
usado para varios individuos diferentes a lo largo de la serie (e.g. en el a?o
1, 10 y 20). Entonces lo que hab?a pensado es hacer un bucle para cada
individuo, pero no consigo que cada vez que cambia el nombre de un individuo
(e.g. en el a?o 10) capture la nueva fecha para determinar si los siguientes
nombres hacen referencia al mismo individuo u a otro muy posterior en el tiempo
(e.g. a?o 20).
> Esta pregunta la pregunte hace tiempo en
stackoverflowhttp://stackoverflow.com/questions/32310520/identify-objects-with-repeated-measures-and-with-the-same-id-between-years,
pero no obtuve una respuesta que solucionara el problema, y los posteriores
intentos que he estado haciendo tampoco han sido muy buenos que se digan (os lo
copio al final del mensaje).
> Por ello os quer?a preguntar si alguno sabe como puedo ir registrando y
cambiando los IDs a lo largo del tiempo.
> Muchas gracias por adelantado, Un cordial saludo, Rub?n
> Codigo usadodatabase es la base de datos con la serie temporalID_original
es el identificado original que tiene cada individuoMonth_Capt es la variable
que me indica en que momento fue capturado cada individuo y por tanto si es
posible o no que el individuo sea el mismo a lo largo del tiempo.
> newID <-sapply(unique(database$ID_original), function(x)
c(0,cumsum(diff(database$Month_Capt[database$ID_original==x]))%%48))names(newID)<-(unique(database$ID_original))
>
new_df<-data.frame(database$ID_original,database$Month_Capt,IDcond=NA,new_ID=NA)for(i
in unique(database$ID_original)){ 
new_df[new_df[,1]==i,3]<-newID[[which(unique(database$ID_original)==i)]]}ltrs<-c(LETTERS,apply(combn(LETTERS,2,simplify
= T),2,function(x) paste(x,sep = "",collapse = "")))
> letterwrap <- function(n, depth = 1) {  args <- lapply(1:depth, FUN =
function(x) return(LETTERS))  x <- do.call(expand.grid, args = list(args,
stringsAsFactors = F))  x <- x[, rev(names(x)), drop = F]  x <-
do.call(paste0, x)  if (n <= length(x)) return(x[1:n])  return(c(x,
letterwrap(n - length(x), depth = depth + 1)))}
> ltrs <- letterwrap(nrow(database)) # Create as many letters as unique
IDs
>
> ltrn<-0for(i in 1:nrow(new_df)){  if(new_df[i,3]==0)
{ltrn<-ltrn+1;new_df[i,4]<-ltrs[ltrn]}  else
{ind<-which(new_df[,1]==new_df[i,1])        ind<-ind[ind<i]       
new_df[i,4]<-tail(new_df[ind,4],1)}}
>   		 	   		
> 	[[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

	[[alternative HTML version deleted]]

Apparently Analagous Threads

Search for more reasonably related threads

R help es - Jan 2016 - Corregir mismo ID para individuos diferentes en una serie temporal

[R-es] Corregir mismo ID para individuos diferentes en una serie temporal

[R-es] Corregir mismo ID para individuos diferentes en una serie temporal

[R-es] Corregir mismo ID para individuos diferentes en una serietemporal

[R-es] Corregir mismo ID para individuos diferentes en una serie temporal

[R-es] Corregir mismo ID para individuos diferentes en una serie temporal

Apparently Analagous Threads