pert.R

# Nodos de la cadena PERT
nodos <- c(1, 2, 3, 4)
names(nodos) <- as.character(nodos)
nodos

## 1 2 3 4 
## 1 2 3 4

nodos["1"]

## 1 
## 1

# Arcos de la cadena PERT
arcos <- list(c(1, 2),
              c(2, 3),
              c(2, 4),
              c(3, 4))
names(arcos) <- as.character(arcos)
arcos

## $`c(1, 2)`
## [1] 1 2
## 
## $`c(2, 3)`
## [1] 2 3
## 
## $`c(2, 4)`
## [1] 2 4
## 
## $`c(3, 4)`
## [1] 3 4

arcos["c(1, 2)"]

## $`c(1, 2)`
## [1] 1 2

# Duracion actividades
duracion <- c(2, 5, 8, 4)

names(duracion) <- names(arcos)
duracion

## c(1, 2) c(2, 3) c(2, 4) c(3, 4) 
##       2       5       8       4

duracion["c(1, 2)"]

## c(1, 2) 
##       2

n <- length(nodos)
m <- length(arcos)


# ignorar -----------------------------------------------------------------

# for (i in 1:length(arcos)){
#   print(1 == arcos[[i]])
# }
# 
# for (i in 1:length(arcos)){
#   print(any(1 == arcos[[i]]))
# }
# 
# for (i in 1:length(arcos)){
#   print(1 %in% arcos)
# }

# map_lgl(arcos, ~ 2 %in% .x)

# for (j in nodos){
#   for (i in 1:length(arcos)){
#     print(j == arcos[[i]])
#   }
# }


# utiles ------------------------------------------------------------------


# Para cada nodo, ver si está en un arco
for (n in nodos){
  for (a in arcos){
    print(n == a)
  }
}

## [1]  TRUE FALSE
## [1] FALSE FALSE
## [1] FALSE FALSE
## [1] FALSE FALSE
## [1] FALSE  TRUE
## [1]  TRUE FALSE
## [1]  TRUE FALSE
## [1] FALSE FALSE
## [1] FALSE FALSE
## [1] FALSE  TRUE
## [1] FALSE FALSE
## [1]  TRUE FALSE
## [1] FALSE FALSE
## [1] FALSE FALSE
## [1] FALSE  TRUE
## [1] FALSE  TRUE

# Para cada nodo, ver si está al final de un arco
for (n in nodos){
  for (a in arcos){
    print(n == a[2])
  }
}

## [1] FALSE
## [1] FALSE
## [1] FALSE
## [1] FALSE
## [1] TRUE
## [1] FALSE
## [1] FALSE
## [1] FALSE
## [1] FALSE
## [1] TRUE
## [1] FALSE
## [1] FALSE
## [1] FALSE
## [1] FALSE
## [1] TRUE
## [1] TRUE

# Función antecesor -------------------------------------------------------

antecesores <- function(vertice, nodos, arcos){
  ant <- c() # vector de antecendentes
  for(i in 1:length(arcos)){ # recorrer cada arco
    for(j in 1:length(nodos)){ # probar con cada nodo
      arco_prueba <- c(nodos[j], vertice) # arco de prueba
      prueba <- arco_prueba == arcos[[i]] # ¿el arco generado está en la lista de arocs?
      if( sum(prueba) == 2 ) # en caso de que el arco generado esté en la lista:
        ant = c(ant, nodos[j]) # añadir al conjunto de antecesores
    }
  }
  
  return(ant)
}

# Ejemplo
# cada vector tiene nombres:
antecesores(vertice = 2, nodos = nodos, arcos = arcos) 

## 1 
## 1

antecesores(vertice = 3, nodos = nodos, arcos = arcos)

## 2 
## 2

antecesores(vertice = 4, nodos = nodos, arcos = arcos)

## 2 3 
## 2 3

# Fechas próximas ---------------------------------------------------------

# Paso 1 

# Conjunto de nodos etiquetados
S <- 1

# Conjunto de etiquetas de fecha más próxima
a <- rep(NA, length(nodos))
names(a) <- names(nodos)
a[1] = 0
a

##  1  2  3  4 
##  0 NA NA NA

no_etiquetados_a <- nodos[! nodos %in% S] # nodos no etiquetados
names(no_etiquetados_a) <- NULL # quitar nombres

# Paso 2 - encerrar en un ciclo while minetras alguna entrada del vector a sea NA

# Probar si los antecesores del nodo ya están etiquetados
antecesores_etiquetados_a <- function(nodo){
  ant_nodo <- antecesores(vertice = nodo, 
                          nodos = nodos, 
                          arcos = arcos)
  n <- length(ant_nodo)
  k = 0 # aumentara en 1 por cada nodo etiquetado
  
  for(antecesor in ant_nodo){
    if(antecesor %in% S){
      k = k + 1
    }
  }
  
  return(k == n)
}

# ejemplo
antecesores_etiquetados_a(2)

## [1] TRUE

antecesores_etiquetados_a(3)

## [1] FALSE

antecesores_etiquetados_a(4)

## [1] FALSE

# que nodos se pueden etiquetar?
nodos_por_etiquetar_a <- c()
for (i in no_etiquetados_a){ # Nodos no etiquetados
  if(antecesores_etiquetados_a(i)) # ¿Antecesores etiquetados?
    # En caso de que si, entonces se puede etiquetar:
    nodos_por_etiquetar_a = c(nodos_por_etiquetar_a, i) 
}

# Ahora se pone la etiqueta de fecha más próxima, i.e., etiqueta "a"
for (i in nodos_por_etiquetar_a) { # se recorre los nodos que se etiquetarán
  candidatos_a <- c() # posibles etiquetas
  for (j in antecesores(i, nodos, arcos)) { # se recorre los antecesores
    etiqueta_arco = paste0("c(", as.character(j), ", ", as.character(i), ")")
    valor = a[as.character(j)] + duracion[etiqueta_arco]
    candidatos_a = c(candidatos_a, valor)
  }
  a[as.character(i)] = max(candidatos_a) # etiqueta del nodo
}

# Actualizar S
S = c(S, nodos_por_etiquetar_a)
no_etiquetados_a = nodos[! nodos %in% S]