def visitNumberFloat(self, ctx):
valor = float(ctx.FLOAT_NUMBER().getText())
nodo = Nodo()
nodo.valor = valor
nodo.tipo = "FLOAT"
#self.pilaValores.append(nodo)
return nodo
def visitNumberInteger(self, ctx):
valor = int(ctx.integer().getText())
nodo = Nodo()
nodo.valor = valor
nodo.tipo = "INTEGER"
#self.pilaValores.append(nodo)
return nodo
def visitAtomString(self, ctx):
nodo = Nodo()
nodo.valor = str(ctx.STRING())
nodo.valor = nodo.valor[1:len(nodo.valor)-1]
nodo.tipo = "STRING"
#self.pilaValores.append(nodo)
return nodo
def buscar_solucion_bfs(conexiones, estado_inicial, solucion):
solucionado = False
nodos_visitados = []
nodos_frontera = []
nodoInicial = Nodo(estado_inicial)
nodos_frontera.append(nodoInicial)
while (not solucionado) and (len(nodos_frontera) != 0):
nodo = nodos_frontera[0]
# extraer nodo y anadirlo a visitados
nodos_visitados.append(nodos_frontera.pop(0))
if (nodo.get_datos() == solucion):
# solucion encontrada
solucionado = True
return nodo
else:
# expandir nodos hijos (ciudades con conexion)
dato_nodo = nodo.get_datos()
lista_hijos = []
for un_hijo in conexiones[dato_nodo]:
hijo = Nodo(un_hijo)
lista_hijos.append(hijo)
if (not hijo.en_lista(nodos_visitados)) and (not hijo.en_lista(nodos_frontera)):
nodos_frontera.append(hijo)
nodo.set_hijos(lista_hijos)
def __init__(self,elem,aristas):
Nodo.__init__(self,elem)
self.aristas = aristas
if aristas == {}:
self.grado = 0
else:
self.grado = len(aristas)
def visitAtomName(self, ctx):
nodo = Nodo()
valor = self.evaluarSimbolo(ctx.NAME())
nodo.tipo = valor.tipo
nodo.valor = valor.valor
nodo.subtipo = valor.subtipo
#self.pilaValores.append(nodo)
return nodo
def insertarPrimero(self, datosAInsertar):
nodo = Nodo()
nodo.datos = datosAInsertar
if self.esVacia():
nodo.siguiente = None
else:
nodo.siguiente = self.lista
self.lista = nodo
def visitIterable_tuple(self, ctx):
valorI = super(GramaticaExtVisitor,self).visit(ctx.test(0))
valorD = super(GramaticaExtVisitor,self).visit(ctx.test(1))
nodo = Nodo()
nodo.tipo = "ITERATOR"
nodo.subtipo = "TUPLE"
nodo.valor = (valorI,valorD)
return nodo
def configurarNodo(self, espacoEstado, nodoAnalisado):
profundidade = nodoAnalisado.profundidade + 1
nodoPai = nodoAnalisado
novoNodo = Nodo(espacoEstado, 0, profundidade, nodoPai)
if self.isNodoJaVisitado(novoNodo) is False:
novoNodo.pesoHeuristica = self.computarHeuristicas(novoNodo.estadoTabuleiro)
self.fronteiras.append(novoNodo)
def visitTestNot(self, ctx):
valor = super(GramaticaExtVisitor,self).visit(ctx.test(0))
nodo = Nodo()
if valor.tipo == "BOOL":
nodo.tipo = "BOOL"
nodo.valor = not valor.valor
else:
ln = -1
self.raiseError(ln, 'Error en los operandos', "Operacion not-test")
return nodo
def visitAtomName(self, ctx):
nodo = Nodo()
valor = self.evaluarSimbolo(ctx.NAME())
nodo.tipo = valor.tipo
nodo.valor = valor.valor
nodo.subtipo = valor.subtipo
print("se ha solicitado: "+str(ctx.NAME())+" con valor: "+str(nodo))
print("en :"+str(self.tablaDeSimbolosActual))
#self.pilaValores.append(nodo)
return nodo
def visitTestExprComp(self, ctx):
valorI = super(GramaticaExtVisitor,self).visit(ctx.expr(0))
valorD = super(GramaticaExtVisitor,self).visit(ctx.expr(1))
nodo = Nodo()
nodo.tipo = "BOOL"
op = ctx.comp_op().getText()
if valorI.tipo == "ITERATOR" or valorD.tipo == "ITERATOR":
ln = -1
self.raiseError(ln, "No es posible realizar este tipo de operacion con elementos iterables", "primitive-expected")
if op == "<":
nodo.valor = valorI.valor < valorD.valor
elif op == ">":
nodo.valor = valorI.valor > valorD.valor
elif op == "==":
nodo.valor = valorI.valor == valorD.valor
elif op == ">=":
nodo.valor = valorI.valor >= valorD.valor
elif op == "<=":
nodo.valor = valorI.valor <= valorD.valor
elif op == "<>":
nodo.valor = valorI.valor <> valorD.valor
elif op == "!=":
print(valorI)
print(valorD)
nodo.valor = valorI.valor != valorD.valor
return nodo
def exitComparisonEval(self, ctx):
valorI = self.pilaValores.pop()
valorD = self.pilaValores.pop()
nodo = Nodo()
op = ctx.comp_op().getText()
if op == "<":
nodo.valor = valorI.valor < valorD.valor
elif op == ">":
nodo.valor = valorI.valor > valorD.valor
elif op == "==":
nodo.valor = valorI.valor == valorD.valor
elif op == ">=":
nodo.valor = valorI.valor >= valorD.valor
elif op == "<=":
nodo.valor = valorI.valor <= valorD.valor
elif op == "<>":
nodo.valor = valorI.valor <> valorD.valor
elif op == "!=":
nodo.valor = valorI.valor != valorD.valor
nodo.tipoValor = "BOOL"
self.pilaValores.append(nodo)
print("Nueva compracion: " + str(nodo.valor))
def visitTestOr(self, ctx):
valorI = super(GramaticaExtVisitor,self).visit(ctx.test(0))
valorD = super(GramaticaExtVisitor,self).visit(ctx.test(1))
nodo = Nodo()
if valorI.tipo == "BOOL" and valorD.tipo == "BOOL":
nodo.tipo = "BOOL"
nodo.valor = valorI.valor or valorD.valor
else:
ln = -1
self.raiseError(ln, 'Error en los operandos', "Operacion or-test")
return nodo
def visitExprXor(self, ctx):
valorI = super(GramaticaExtVisitor,self).visit(ctx.expr(0))
valorD = super(GramaticaExtVisitor,self).visit(ctx.expr(1))
nodo = Nodo()
if valorI.tipo == "INTEGER" or valorD.tipo == "INTEGER":
nodo.tipo = "INTEGER"
nodo.valor = valorI.valor ^ valorD.valor
else:
ln = -1
self.raiseError(ln, 'Error en los operandos', "Operacion bit-xor")
return nodo
def insertarUltimo(self, datosAInsertar):
nodo = Nodo()
nodo.datos = datosAInsertar
nodo.siguiente = None
if self.esVacia():
self.lista = nodo
else:
copiaLista = self.lista
while copiaLista.siguiente != None:
copiaLista = copiaLista.siguiente
copiaLista.siguiente = nodo
def exitPowerEval(self, ctx):
if len(ctx.atom_stmt()) == 2:
valorD = self.pilaValores.pop()
valorI = self.pilaValores.pop()
if self.numerico(valorD) and self.numerico(valorI):
nodo = Nodo()
nodo.tipoValor = "FLOAT"
nodo.valor = valorI.valor ** valorD.valor
self.pilaValores.append(nodo)
print("Nueva potencia: " + str(nodo.valor))
else:
raise RuntimeError("Error en los operadores, deben ser de tipo entero")
def exitShiftRight(self, ctx):
if len(ctx.arith_expr()) == 2:
valorD = self.pilaValores.pop()
valorI = self.pilaValores.pop()
if valorD.tipoValor == "INTEGER" and valorI.tipoValor == "INTEGER":
nodo = Nodo()
nodo.tipoValor = "INTEGER"
nodo.valor = valorD.valor >> valorI.valor
self.pilaValores.append(nodo)
print("Nueva shift right: " + str(nodo.valor))
else:
raise RuntimeError("Error en los operandos, deben ser de tipo entero")
def exitAndTest(self, ctx):
if len(ctx.not_test()) == 2:
valorD = self.pilaValores.pop()
valorI = self.pilaValores.pop()
if valorD.tipoValor == "BOOL" and valorI.tipoValor == "BOOL":
nodo = Nodo()
nodo.tipoValor = "BOOL"
nodo.valor = valorD.valor and valorI.valor
self.pilaValores.append(nodo)
print("Nuevo ORT: " + str(nodo.valor))
else:
raise RuntimeError("Error en los operandos, deben ser de tipo logico")
def visitExprModule(self, ctx):
valorI = super(GramaticaExtVisitor,self).visit(ctx.expr(0))
valorD = super(GramaticaExtVisitor,self).visit(ctx.expr(1))
nodo = Nodo()
if valorI.tipo == "INTEGER" or valorD.tipo == "INTEGER":
nodo.tipo = "INTEGER"
nodo.valor = valorI.valor % valorD.valor
print(str(valorI)+" : "+str(valorD));
else:
ln = -1
self.raiseError(ln, 'Error en los operandos', "Operacion modulo")
return nodo
def visitIterable_list(self, ctx):
nodo = Nodo()
nodo.tipo = "ITERATOR"
nodo.subtipo = "LIST"
nodo.valor = []
if ctx.list_element() != None:
valor = super(GramaticaExtVisitor,self).visit(ctx.list_element().test())
nodo.valor.append(valor)
if ctx.list_element() != None and ctx.list_element().sublist_element() != None:
for el in ctx.list_element().sublist_element():
valor = super(GramaticaExtVisitor,self).visit(el.test())
nodo.valor.append(valor)
return nodo
def visitIterable_name(self,ctx):
valor = self.tablaDeSimbolosActual.resolver(ctx.NAME())
if valor == None:
ln = -1
self.raiseError(ln, 'El simbolo no se ha encontrado', ctx.NAME())
if valor.tipo != "ITERATOR":
ln = -1
self.raiseError(ln, 'El nombre no es de tipo iterador', ctx.NAME())
nodo = Nodo()
nodo.tipo = valor.tipo
nodo.subtipo = valor.subtipo
nodo.valor = valor.valor
return nodo
def visitExprMinus(self, ctx):
valorI = super(GramaticaExtVisitor,self).visit(ctx.expr(0))
valorD = super(GramaticaExtVisitor,self).visit(ctx.expr(1))
nodo = Nodo()
if self.numerico(valorI) and self.numerico(valorD):
if valorI.tipo == "FLOAT" or valorD.tipo == "FLOAT":
nodo.tipo = "FLOAT"
else:
nodo.tipo = "INTEGER"
nodo.valor = valorI.valor - valorD.valor
else:
ln = -1
self.raiseError(ln, 'Error en los operandos', "Operacion resta")
return nodo
def exitTermModule(self, ctx):
if len(ctx.power()) == 2:
valorD = self.pilaValores.pop()
valorI = self.pilaValores.pop()
if self.numerico(valorD) and self.numerico(valorI):
nodo = Nodo()
if valorD.tipoValor == "FLOAT" or valorI.tipoValor == "FLOAT":
nodo.tipoValor = "FLOAT"
else:
nodo.tipoValor = "INTEGER"
nodo.valor = valorD.valor % valorI.valor
self.pilaValores.append(nodo)
print("Nuevo modulo: " + str(nodo.valor))
else:
raise RuntimeError("Error en los operandos, deben ser de tipo numerico")
def visitIf_stmt(self, ctx):
cond = super(GramaticaExtVisitor,self).visit(ctx.test())
if self.evaluarIf(cond,ctx.stmt()) :
return None
if len(ctx.elif_stmt()) > 0:
for nodo_elif in ctx.elif_stmt():
cond = super(GramaticaExtVisitor,self).visit(nodo_elif.test())
if self.evaluarIf(cond,nodo_elif.stmt()):
return None
if len(ctx.else_stmt()) > 0:
nodo = Nodo()
nodo.tipo = "BOOL"
nodo.valor = True
self.evaluarIf(nodo,ctx.else_stmt().stmt())
return None
def pulaDown(self, origemX, origemY, nodo, I, E):
if origemX > 1 and origemX <= 6:
if nodo.estado[origemX - 1][origemY] == 1 and nodo.estado[origemX - 2][origemY] == 1:
filho = Nodo(nodo.estado, nodo)
#filho.proximo = nodo
filho.estado[origemX][origemY] = 1 #posicao vazia fica com peca
filho.estado[origemX - 1][origemY] = 2 #posicao com peca fica vazia
filho.estado[origemX - 2][origemY] = 2
filho.valor = self.valor(filho.estado)
if self.valida(I, filho.estado) == 1:
E.append(filho)
return 1
return -1
def pulaDireita(self, origemX, origemY, nodo, I, E):
if origemY > 1 and origemY <= 6:
if nodo.estado[origemX][origemY - 1] == 1 and nodo.estado[origemX][origemY - 2] == 1:
filho = Nodo(nodo.estado, nodo)
#filho.proximo = nodo
filho.estado[origemX][origemY] = 1
filho.estado[origemX][origemY - 1] = 2
filho.estado[origemX][origemY - 2] = 2
filho.valor = self.valor(filho.estado)
if self.valida(I, filho.estado) == 1:
E.append(filho)
return 1
return -1
def pulaEsquerda(self, origemX, origemY, nodo, I, E):
if origemY >= 0 and origemY < 5:
if nodo.estado[origemX][origemY + 1] == 1 and nodo.estado[origemX][origemY + 2] == 1:
filho = Nodo(nodo.estado, nodo)
#filho.proximo = nodo
filho.estado[origemX][origemY] = 1
filho.estado[origemX][origemY + 1] = 2
filho.estado[origemX][origemY + 2] = 2
filho.valor = self.valor(filho.estado)
if self.valida(I, filho.estado) == 1:
E.append(filho)
return 1
return -1
def visitIterable_map(self, ctx):
nodo = Nodo()
nodo.tipo = "ITERATOR"
nodo.subtipo = "MAP"
nodo.valor = {}
if ctx.map_element() != None:
indice = super(GramaticaExtVisitor,self).visit(ctx.map_element().test(0))
valor = super(GramaticaExtVisitor,self).visit(ctx.map_element().test(1))
nodo.valor[indice.valor] = valor
if ctx.map_element() != None and ctx.map_element().submap_element() != None:
for el in ctx.map_element().submap_element():
indice = super(GramaticaExtVisitor,self).visit(el.test(0))
valor = super(GramaticaExtVisitor,self).visit(el.test(1))
nodo.valor[indice.valor] = valor
return nodo
def visitTest_iterable_in(self,ctx):
vl = super(GramaticaExtVisitor,self).visit(ctx.test())
iterab = super(GramaticaExtVisitor,self).visit(ctx.iterable())
if iterab == None or vl == None:
ln = -1
self.raiseError(ln, "No se han proporcionado elementos para operar", "operators-expected")
if iterab.tipo != "ITERATOR":
ln = -1
self.raiseError(ln, "No es posible realizar esta operacion sobre un elemento no iterable", "iterable-expected")
nodo = Nodo()
nodo.tipo = "BOOL"
nodo.valor = False
for t in iterab:
if t.tipo == vl.tipo and t.valor == vl.valor:
nodo.valor = True
return nodo
return nodo
def visitTest_iterable_in(self, ctx):
vl = super(GramaticaExtVisitor, self).visit(ctx.test())
iterab = super(GramaticaExtVisitor, self).visit(ctx.iterable())
if iterab == None or vl == None:
ln = -1
self.raiseError(ln,
"No se han proporcionado elementos para operar",
"operators-expected")
if iterab.tipo != "ITERATOR":
ln = -1
self.raiseError(
ln,
"No es posible realizar esta operacion sobre un elemento no iterable",
"iterable-expected")
nodo = Nodo()
nodo.tipo = "BOOL"
nodo.valor = False
for t in iterab:
if t.tipo == vl.tipo and t.valor == vl.valor:
nodo.valor = True
return nodo
return nodo
def astar(puzzle_str):
# return []
puzzle = puzzle_str #"104253876" #sol
# puzzle = "123406785" #no sol
destino = "123456780"
# f,g,h
abierto = [ Nodo(puzzle) ]
abierto_set = set ( abierto )
cerrado = set()
actual = puzzle
while len(abierto) != 0:
# print("Abiertos",len(abierto))
# print("Cerrados",len(cerrado))
actual = heapq.heappop(abierto)
abierto_set.discard(actual)
#print(actual.clave,"-.-.-.-")
cerrado.add( actual )
if actual.clave == destino:
# print("Fin")
respuesta = []
temp = actual
while temp.clave!=puzzle:
#print(temp.clave)
temp = temp.parent
respuesta.append(temp.clave)
respuesta.reverse()
respuesta.pop(0)
return respuesta
movs = get_mov(actual.clave)
for m in movs:
nuevo_nodo = Nodo ( movement(actual.clave,m) , actual)
# padres[nuevo_nodo]=actual[3]
if nuevo_nodo not in cerrado:
nuevo_nodo.g = actual.g + distancia(actual.clave,nuevo_nodo.clave)
nuevo_nodo.h = distancia(nuevo_nodo.clave,destino)
nuevo_nodo.f = nuevo_nodo.g+nuevo_nodo.h
if nuevo_nodo in abierto_set:
if all( nuevo_nodo.g > x.g for x in abierto ) :
# print("here")
continue
heapq.heappush(abierto, nuevo_nodo )
abierto_set.add(nuevo_nodo)
print ( "Ruta no encontrada")
return []
def inicializar_memoria(cls): # Inicializa la memoria principal con todos los frames disponibles. cls.memoria_principal = [Frame() for i in range(cls.tamanno_memoria_principal)] # Comprueba si existe el directorio de memoria, si existe lo elimina. Crea uno nuevo if os.path.exists(cls.ruta_nodo_uno): cls.finalizar_memoria() os.makedirs(cls.ruta_nodo_uno) # Agrega el nodo por defecto a la tabla de nodos. cls.tabla_nodos.append(Nodo(1, cls.ruta_nodo_uno)) # Pone la bandera de que la memoria fue inicializada. cls.memoria_inicializada = True
def crear_rama(linea, n_actual, d_nodos):
linea = linea.split(",")
tiempo = float(linea[0])
informacion=tuple(linea[1:])
#print(informacion)
#inp=input(">")
n_nuevo = Nodo(tiempo, informacion) # creacion del nodo nuevo
id_nodo = informacion
if id_nodo in d_nodos: # busqueda de nodo existente
n_existente = d_nodos[id_nodo]
t_registrado=n_existente.getTiempo()
t_actual=n_nuevo.getTiempo()
if t_actual>t_registrado and t_actual<1:
n_existente.setTiempo(t_actual)
n_actual.siguiente_nodo(n_existente) # enlace de nodo existete
n_actual = n_existente
extraccion_secuencia(n_actual)
else:
d_nodos[id_nodo] = n_nuevo
n_actual.siguiente_nodo(n_nuevo) # enlace de nodo nuevo
n_actual = n_nuevo
return n_actual
def crear_rama(linea, bandera):
global conteoMax, n_actual
tiempo = float(linea[0])
informacion = tuple(linea[1:])
n_nuevo = Nodo(tiempo, informacion) # creacion del nodo nuevo
id_nodo = informacion
if id_nodo in d_nodos: # busqueda de nodo existente
n_existente = d_nodos[id_nodo]
t_registrado = n_existente.getTiempo()
t_actual = n_nuevo.getTiempo()
if t_actual > t_registrado and t_actual < 1:
n_existente.setTiempo(t_actual)
n_actual.siguiente_nodo(n_existente) # enlace de nodo existete
n_actual = n_existente
n_actual.cuenta(
) # Al existir el nodo, se lleva un conteo de las veces que ha sido usado
if n_actual.getCuenta() >= conteoMax:
conteoMax = n_actual.getCuenta() # actualizacion del conteoMaximo
else:
d_nodos[id_nodo] = n_nuevo
n_actual.siguiente_nodo(n_nuevo) # enlace de nodo nuevo
n_actual = n_nuevo
def insert(self,i,elemento):
if i < 0 or i > self.len:
raise IndexError('Posición inválida')
nuevo = Nodo(elemento)
if i == 0:
nuevo.prox = self.prim
self.prim = nuevo
actual = self.prim.prox
for i in range(1,self.len):
actual = actual.prox
actual.prox = self.prim
else:
anterior = self.prim
for pos in range(1,i):
anterior = anterior.prox
nuevo.prox = anterior.prox
anterior.prox = nuevo
self.len += 1
def union(AFN_1, AFN_2):
nodoInicio = Nodo(1, "1")
nodoFin = Nodo(3, "2")
afnUnido = AFN(["Nodos", "E"], [Arco(nodoInicio, []), Arco(nodoFin, [])])
for lista in (AFN_1.listaIndices, AFN_2.listaIndices):
for indice in lista:
if indice not in afnUnido.listaIndices:
afnUnido.listaIndices.append(indice)
for transiciones in (AFN_1.tablaTransiciones, AFN_2.tablaTransiciones):
for transicion in transiciones:
if transicion not in afnUnido.tablaTransiciones:
transicion.nodoInicio.numeracion = len(
afnUnido.tablaTransiciones)+1
if transicion.nodoInicio.tipo == 1:
afnUnido.buscarNodo(nodoInicio).nodosDestino.append(
[transicion.nodoInicio, "E"])
afnUnido.tablaTransiciones.append(transicion)
elif transicion.nodoInicio.tipo == 3:
afnUnido.tablaTransiciones.append(
Arco(transicion.nodoInicio, [[nodoFin, "E"]]))
else:
afnUnido.tablaTransiciones.append(transicion)
transicion.nodoInicio.tipo = 2
return afnUnido
def conseguir_ciudades(self): #regresa una lista de nodo, cada nodo es una ciudad
ciudades= open('servidor/src/Estados.txt', 'r').read().split("\n")
lista_ciudades=[]
for ciudad in ciudades:
nombre_ciudad= ciudad.split(":")[0]
lista_hijos=ciudad.split(":")[1].split(",")
lista_dos_hijos =[]
for hijo in lista_hijos:
lista_aux=hijo.split("-")
hijo = [lista_aux[1],int(lista_aux[0])]
lista_dos_hijos.append(hijo)
coordenadas = [int(x) for x in ciudad.split(":")[2].split("-")]
lista_ciudades.append(Nodo(nombre_ciudad,lista_dos_hijos,coordenadas))
return lista_ciudades
def criarNodoFilho(self, nodo, indice, profundidade):
linha, coluna = Utils.parserJogada(str(indice))
index = int(str(linha) + str(coluna))
if (profundidade % 2) != 0:
pecaJogada = Peca.COMPUTADOR
else:
pecaJogada = Peca.JOGADOR
tabuleiro = copy.deepcopy(nodo._board)
tabuleiro[linha][coluna] = pecaJogada
isNodoFolha = self.verificaVitoriaPecaJogada(tabuleiro, linha, coluna,
pecaJogada)
return Nodo(index, tabuleiro, pecaJogada, None, profundidade,
isNodoFolha, -9999999999, 9999999999)
def agregarDato(self, vertice1, vertice2):
nodo = Nodo(vertice2)
nodo.siguiente = self.grafo[vertice1]
self.grafo[vertice1] = nodo
nodo = Nodo(vertice1)
nodo.siguiente = self.grafo[vertice2]
self.grafo[vertice2] = nodo
def cargarProceso_PartDinamico_MejorAjuste(self, nombre, tamanio):
if ((self.nodo == None) and (tamanio <= self.memoriaDisponoble)):
self.agregar(nombre, tamanio)
self.agregar("", self.memoriaDisponoble - tamanio)
else:
#Buscando las particiones mayores o iguales libres
nodoActual = self.nodo
tamaniosProcesosMayoresOIguales = []
tamanioMejorAjuste = 0
while nodoActual:
if (nodoActual.tamanioTotal >= tamanio
and nodoActual.nombre == ""):
tamaniosProcesosMayoresOIguales.append(
nodoActual.tamanioTotal)
nodoActual = nodoActual.siguiente
#print(tamaniosProcesosMayoresOIguales)
tamaniosProcesosMayoresOIguales.sort()
if len(tamaniosProcesosMayoresOIguales) > 0:
tamanioMejorAjuste = tamaniosProcesosMayoresOIguales[0]
#print(tamanioMejorAjuste)
#Recorrer la lista buscando la partición más ajustada.
else:
return
nodoActual2 = self.nodo
while nodoActual2:
if (nodoActual2.nombre == nombre):
print("Hay el mismo nombre ya")
break
else:
if (nodoActual2.tamanioTotal == tamanioMejorAjuste
and nodoActual2.nombre == ""):
nodoActual2.nombre = nombre
self.ultimoIngresado = nodoActual2
if (nodoActual2.tamanioTotal > tamanio):
tamanioQueResta = nodoActual2.tamanioTotal - tamanio
nodoActual2.tamanioTotal = tamanio
siguiente_temp = nodoActual2.siguiente
#nodoActual2.siguiente = self.agregar("", tamanioQueResta)
nodoActual2.siguiente = Nodo("", tamanioQueResta)
nodoActual2.siguiente.siguiente = siguiente_temp
print("Ingresé y metí %s, %s" % (nombre, tamanio))
break
nodoActual2 = nodoActual2.siguiente
def cargarProceso_PartDinamico_PrimerAjuste(self, nombre, tamanio):
if ((self.nodo == None) and (tamanio <= self.memoriaDisponoble)):
self.agregar(nombre, tamanio)
if (tamanio != self.memoriaDisponoble):
self.agregar("", self.memoriaDisponoble - tamanio)
else:
#Buscando las particiones mayores o iguales libres
nodoIterar = self.nodo
tamaniosProcesosMayoresOIguales = []
tamanioMejorAjuste_2 = 0
while nodoIterar:
if (nodoIterar.tamanioTotal >= tamanio
and nodoIterar.nombre == ""):
tamaniosProcesosMayoresOIguales.append(
nodoIterar.tamanioTotal)
nodoIterar = nodoIterar.siguiente
#print(tamaniosProcesosMayoresOIguales)
tamaniosProcesosMayoresOIguales.sort()
if len(tamaniosProcesosMayoresOIguales) > 0:
tamanioMejorAjuste_2 = tamaniosProcesosMayoresOIguales[0]
#print(tamanioMejorAjuste)
#Recorrer la lista buscando la partición más ajustada.
else:
return
nodoActual = self.nodo
while nodoActual:
if (nodoActual.nombre == nombre):
break
if (nodoActual.tamanioTotal >= tamanio
and nodoActual.nombre == ""):
nodoActual.nombre = nombre
self.ultimoIngresado = nodoActual
if (nodoActual.tamanioTotal > tamanio):
tamanioQueResta = nodoActual.tamanioTotal - tamanio
nodoActual.tamanioTotal = tamanio
siguiente_temp = nodoActual.siguiente
#nodoActual.siguiente = self.agregar("", tamanioQueResta)
nodoActual.siguiente = Nodo("", tamanioQueResta)
nodoActual.siguiente.siguiente = siguiente_temp
break
nodoActual = nodoActual.siguiente
def main():
nombre_archivo="lista_acciones.txt"
n_raiz=Nodo(0,0) #Creacion del nodo Raiz
n_actual=n_raiz
d_nodos={"root":n_raiz} #creacion de diccionario de nodos
global secuencia
secuencia=[] #Lista con la secuencia de elementos
global conteoMax
conteoMax=0 #la mayor cantidad de veces que se ha visitado un
global l_secuencias
l_secuencias=[]
t_uso=0
archivo = open(nombre_archivo, "r") #lectura del archivo
#print(len(archivo.readlines()))
for linea in archivo.readlines():
if linea.count("...")>=1:
#print (linea.split(" ")[1])
t_uso+=float(linea.split(" ")[1])
else:
if len(linea)>2 and len(linea.split(","))>2:
#print(linea)
n_actual=crear_rama(linea, n_actual, d_nodos)
archivo.close()
#Se confirman la secuencias obtenidas
print("tiempo de uso = ", t_uso)
print("numero de nodos = ", len(d_nodos))
print("ConteoMax = ", conteoMax)
print("Numero de secuencias = ", len(l_secuencias))
print("Lista de Nodos: \n")
#print(d_nodos)
for s in l_secuencias:
print (s)
for e in s:
print (e.getInformacion())
print(e.getCuenta())
print("")
def push(self, nomeNodo, indice):
if (indice >= 0):
#crio o primeiro nodo
nodoCriado = Nodo(nomeNodo)
#sprint(nodoCriado)
if self.verificarListaVazia():
#inserir nodo em uma lista: temos so um nodo e portanto ele é o primeiro e o ultimo
self.primeiro = nodoCriado
self.ultimo = nodoCriado
else:
#lista nao esta vazia - vamos comercar inserindo no inicio
if (indice == 0):
nodoCriado.setProximo(self.primeiro)
self.primeiro = nodoCriado
elif (indice >= self.tamanhoLista): #inserir no final
self.ultimo.setProximo(nodoCriado)
self.ultimo = nodoCriado
else: #inserir no meio
#preciso percorrer a lista até encontrar a posição desejada
nodoAnterior = self.primeiro #backup do primeiro nodo
nodoAtual = self.primeiro.getProximo()
indiceAtual = 1
#se nao é o primeiro nodo
#comeco a percorrer a lista até encontrar
while (nodoAtual != None):
if (indiceAtual == indice):
#primeiro inseri o nodo no meio da lista
nodoCriado.setProximo(nodoAtual)
#atualizei o encadeamento
nodoAnterior.setProximo(nodoCriado)
break
nodoAnterior = nodoAtual
nodoAtual = nodoAtual.getProximo()
indiceAtual += 1
self.tamanhoLista += 1
def AgregarPersonal(self, personal):
try:
if (type(personal) == Docente
or (type(personal) == DocenteInvestigador)
or (type(personal) == Investigador)
or (type(personal) == PersonalApoyo)):
nodo = Nodo(personal)
if (self.__comienzo == None):
nodo.setSiguiente(self.__comienzo)
self.__comienzo = nodo
self.__actual = nodo
self.__tope += 1
else:
aux = self.__comienzo
while (aux.getsiguiente() != None):
aux = aux.getsiguiente()
nodo.setSiguiente(aux.getsiguiente)
aux.setSiguiente(nodo)
self.__tope += 1
else:
raise TypeError()
except TypeError:
print('No es agente')
import time, sys
from Nodo import Nodo
from Grafo import GraphClass
from _graph.GraphPro import GraphPro
n_raiz = Nodo(0, 0) # Creacion del nodo Raiz
n_actual = n_raiz
d_nodos = {"root": n_raiz} # creacion de diccionario de nodos
secuencia = [] # Lista con la secuencia de elementos
conteoMax = 0 # la mayor cantidad de veces que se ha visitado un
d_secuencias = {}
l_ignoradas = []
l_secuencias = []
l_conteo = []
t_inicial = time.time()
lista = []
conteo_tareas = 0
inp = 0
def crear_rama(linea, bandera):
global conteoMax, n_actual
tiempo = float(linea[0])
informacion = tuple(linea[1:])
n_nuevo = Nodo(tiempo, informacion) # creacion del nodo nuevo
id_nodo = informacion
if id_nodo in d_nodos: # busqueda de nodo existente
n_existente = d_nodos[id_nodo]
t_registrado = n_existente.getTiempo()
t_actual = n_nuevo.getTiempo()
def __init__(self, nombreNodo, fila, columna, valor):
Nodo.__init__(self, nombreNodo, fila, columna, valor)
def ConvertirEnAFD(self): #Metodo que transforma un AFND a un AFD
if self.esAFD(): #Si el AF ya es un AFD devolvemos la instancia
return self
tempNodoID = 1 #Iniciamos un contador para los nodos que usaremos para eliminar las secuencias con longitud mayor que 1
for nodoNombre, nodo in iter(
self.nodos.items()): #Iteramos sobre los nodos
for simbolo, transicion in iter(nodo.ObtenerTransiciones().items(
)): #Obtenemos las transiciones de cada nodo
if len(
simbolo
) > 1: #Revisamos si la secuencia tiene longitud mayor que 1
rsimbolo = simbolo[::-1] #Invertimos la secuencia
ultimoNodo = transicion #Cada nodo que vayamos creando apuntara al ultimo creado, en el primer caso es a la transicion completa del simbolo
tempNodoNombre = None #Asignamos una variable con el nombre del ultimo nodo temporal creado para usarlo en la transicion del nodo inicial
for i in range(
0, (len(rsimbolo) - 1)
): #Leemos la secuencia invertida caracter a caracter, excepto por el ultimo (o sea, el primero de la secuencia) ya que ese lo usaremos en el nodo inicial
sSimbolo = rsimbolo[
i] #Obtenemos el caracter de la secuencia
tempNodoNombre = "temp%s" % (
tempNodoID
) #Creamos un nodo temporal de nombre "tempID", donde ID lo obtenemos del contador incremental. El nodo no es final.
tempNodo = Nodo(tempNodoNombre, False)
for siguienteNodo in ultimoNodo: #Si es la primera iteracion haremos la transicion desde el nodo a todos los que apuntaba la secuencia inicial, si es un una iteracion mayor apuntaremos el nodo al ultimo nodo temporal creado
tempNodo.AgregarTransicion(sSimbolo, siguienteNodo)
self.AgregarNodo(tempNodo) #Agregamos el nodo al AF
ultimoNodo = [
tempNodoNombre
] #Asignamos la variable ultimoNodo con el nodo recien creado para la siguiente iteracion
tempNodoID += 1 #Aumentamos el contador del nodo intermedio
nodo.RemueveTransicion(
simbolo
) #Luego de desarmar la secuencia eliminamos la transicion del nodo original y creamos una transicion al ultimo nodo temporal creado
nodo.AgregarTransicion(simbolo[0], tempNodoNombre)
self.simbolos = [] #Actualizamos el listado de simbolos validos
self.ActualizarSimbolos()
nuevoAF = AF() #Instanciamos un nuevo AF para el AFD
contadorNodos = 0 #Creamos un contador para los nombres de los nodos
#Creamos diccionarios para asociar grupos de nodos con su nombre y viceversa
nombreNodosporTransiciones = {
} #Get nodoNombre using the group of nodos
transicionesporNombreNodo = {
} #Get group of nodos using the nodoNombre
nodos = {} #Creamos un diccionario de nodos
nodosaIterar = [
] #Creamos una lista con los nuevos nodos que crearemos, como solo agregaremos nodos no hay problemas en modificarlo mientras iteramos
primerNodo = next(iter(self.nodos.values(
))) #Asumimos que el primer nodo del AFD es el nodo inicial (Premisa)
transiciones = self.ConseguirClausura([
primerNodo.ObtenerNombre()
]) #Obtenemos la clausura del nodo inicial
transicionString = '|'.join(
str(v) for v in transiciones
) #Creamos un string con los nodos obtenidos en la clausura, porque las llaves de los diccionarios no pueden ser mutables
nodoNombre = "Q" + str(
contadorNodos) #Asignamos el nombre del nodo inicial
nombreNodosporTransiciones[
transicionString] = nodoNombre #Asociamos el nombre del nuevo nodo con los nodos primitivos que lo componen
transicionesporNombreNodo[nodoNombre] = transiciones
nodosaIterar.append(
nodoNombre) #Agregamos el nodo al listado de nodos por iterar
esFinal = self.nuevoNodoEsFinal(
transiciones) #Determinamos si el nuevo nodo sera final
nodo = Nodo(nodoNombre,
esFinal) #Creamos un nuevo nodo y lo agregamos al AFD
nuevoAF.AgregarNodo(nodo)
nodos[
nodoNombre] = nodo #Agregamos el nodo al listado de nodos usando el nombre como llave
contadorNodos += 1 #Aumentamos el contador de nodos
for nodoaIterar in nodosaIterar: #Iteramos sobre los nodos que vamos creando
for simbolo in self.simbolos: #Iteramos sobre los simbolos validos
transiciones = self.ConseguirTransiciones(
transicionesporNombreNodo[nodoaIterar], simbolo
) #Obtenemos las transiciones de los nodos primitivos que componen el nuevo nodo usando un simbolo especifico. Este metodo tambien devuelve la clausura.
transicionString = '|'.join(str(v) for v in transiciones)
if transicionString in nombreNodosporTransiciones: #Verificamos si tenemos un "nuevo nodo" compuesto por el listado de "nodos primitivos" que obtuvimos
nodos[nodoaIterar].AgregarTransicion(
simbolo, nombreNodosporTransiciones[transicionString]
) #Si ya hemos creado el nuevo nodo solo agregamos la transicion
else:
nodoNombre = "Q" + str(
contadorNodos
) #Si no tenemos un "nodo nuevo" compuesto por el listado de nodos primitivos, lo creamos, y creamos el nombre del nodo usando el iterador
nombreNodosporTransiciones[
transicionString] = nodoNombre #Asociamos el nombre del nodo al listado de nodos primitivo y viceversa
transicionesporNombreNodo[nodoNombre] = transiciones
nodosaIterar.append(
nodoNombre
) #Agregamos el nuevo nodo al listado de nodos por iterar
esFinal = self.nuevoNodoEsFinal(
transiciones
) #Verificamos si el nuevo nodo va a ser final
nodo = Nodo(
nodoNombre,
esFinal) #Creamos el nuevo nodo y lo agregamos al AFD
nuevoAF.AgregarNodo(nodo)
nodos[
nodoNombre] = nodo #Agregamos el nuevo nodo al listado de nodos
contadorNodos += 1 #Aumentamos el contador de nodos
nodos[nodoaIterar].AgregarTransicion(
simbolo, nodoNombre
) #Agregamos la transicion al nodo recien creado
nuevoAF.ActualizarSimbolos(
) #Actualizamos los simbolos validos en el AFD
return nuevoAF #Devolvemos el AFD
def __init__(self, nombre, f, c):
listaDeListas = ListaDoble()
listaDeColumna = ListaDoble()
self.primero = Nodo(nombre, listaDeListas, listaDeColumna, f, c)
class Lista:
def __init__(self):
self.cabeza = Nodo()
self.long = 0
def set_cabeza(self, x):
self.cabeza = x
def get_cabeza(self):
return self.cabeza
def get_long(self):
return self.long
def insertar_ordenado(self, dato):
nuevo = Nodo(dato)
if self.get_cabeza().get_valor() is None:
self.set_cabeza(nuevo)
elif nuevo.get_valor() < self.get_cabeza().get_valor():
nuevo.set_sig(self.get_cabeza())
self.set_cabeza(nuevo)
else:
ant = self.get_cabeza()
act = self.cabeza.get_sig()
# sig = self.cabeza.get_sig()
# print(sig.valor)
while act is not None and act.valor < nuevo.get_valor():
ant = ant.get_sig()
act = act.sig
nuevo.set_sig(ant.get_sig())
ant.set_sig(nuevo)
self.long += 1
def mostrar_lista(self):
aux = self.get_cabeza()
while aux is not None:
print(aux.get_valor())
aux = aux.get_sig()
def eliminar_elem(self, dato):
elim = False
if self.cabeza is not None:
aux = self.cabeza
if self.cabeza.valor == dato:
self.cabeza = self.cabeza.sig
aux = None
else:
ant = self.cabeza
act = self.cabeza.sig
while act is not None and act.valor != dato:
ant = ant.sig
act = act.sig
ant.sig = act.sig
act = None
self.long -= 1
elim = True
return elim
def __init__(self):
self.cabeza = Nodo()
self.long = 0
def __init__(self, nombreNodo, fila=-1, columna=-1, valor=None):
Nodo.__init__(self, nombreNodo, fila, columna, valor)
def ingresarNodo(self, nuevoNombre):
self.nombres.append(nuevoNombre)
self.nodos.append([nuevoNombre, Nodo(nuevoNombre)])
def __init__(self, nombreNodo, fila, columna, valor):
Nodo.__init__(self, nombreNodo, fila, columna, valor)
self.tipo = Type_Expresion(Data_Type.non)
self.valorExpresion = None
def addNodo(self, nodo):
if nodo not in self.V:
self.V[nodo]= Nodo(nodo)
def enterAtomNone(self, ctx):
nodo = Nodo()
nodo.valor = None
nodo.tipoValor = "NONE"
self.pilaValores.append(nodo)
def casoBase(notacion):
lista_nodos = [Nodo(1, "1"), Nodo(3, "2")]
return AFN(["Nodos", notacion],
[Arco(lista_nodos[0], [[lista_nodos[1], notacion]]),
Arco(lista_nodos[1], [])])
def enterAtomFalse(self, ctx):
nodo = Nodo()
nodo.valor = False
nodo.tipoValor = "BOOL"
self.pilaValores.append(nodo)
def enterNumberFloat(self, ctx):
valor = float(ctx.FLOAT_NUMBER().getText())
nodo = Nodo()
nodo.valor = valor
nodo.tipoValor = "FLOAT"
self.pilaValores.append(nodo)
def enterNumberInteger(self, ctx):
valor = int(ctx.integer().getText())
nodo = Nodo()
nodo.valor = valor
nodo.tipoValor = "INTEGER"
self.pilaValores.append(nodo)
