def main():
while True:
printMenu()
inputs = input("Seleccione una opción para continuar\n")
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
catalog = initCatalog()
loadData(catalog)
elif int(inputs[0]) == 2:
verticesNum, edgesNum = controller.countNodesEdges(catalog)
print("El grafo tiene: ", verticesNum, " nodos y", edgesNum,
" enlaces")
elif int(inputs[0]) == 3:
vertices = input(
"Ingrese el vertice origen y destino. (Ejemplo: 'ALB-5-12 LAX-5-12')\n"
)
path = controller.getShortestPath(catalog, vertices)
if path == 'No hay camino' or path == 'No existen los vértices':
print(path)
else:
print("El camino de menor costo entre los vertices es:")
totalDist = 0
while not stk.isEmpty(path):
step = stk.pop(path)
totalDist += step['weight']
print(step['vertexA'] + "-->" + step['vertexB'] +
" costo: " + str(step['weight']))
print("Total: " + str(totalDist))
else:
sys.exit(0)
sys.exit(0)
def main():
datos_cargados = False
while True:
printMenu()
inputs = input("Seleccione una opción para continuar\n")
if int(inputs[0]) == 1: # 1- Cargar información
if not datos_cargados:
print("Cargando información de los archivos ....")
catalog = initCatalog()
loadData(catalog)
datos_cargados = True
else:
print("Los datos ya han sido cargados previamente.")
elif int(inputs[0]) == 2: # 2- Contar nodos y enlances cargados
if datos_cargados:
verticesNum, edgesNum = controller.countNodesEdges(catalog)
print("El grafo tiene: ", verticesNum, " nodos y", edgesNum,
" enlaces")
else:
print(
"No se han cargado los datos previamente. Carguelos e intente de nuevo."
)
elif int(inputs[0]) == 3: # 3- Contar componentes conectados
if datos_cargados:
Num_comp_conectados = controller.ComponentesConectados(
catalog['flightGraph'])
print("El grafo tiene: ", Num_comp_conectados,
" componentes conectados ó Clusters.")
else:
print(
"No se han cargado los datos previamente. Carguelos e intente de nuevo."
)
elif int(
inputs[0]
) == 4: # 4- Obtener el camino de menor costo entre dos vértices usando Dijkstra (origen destino)
if datos_cargados:
vertices = input("Ingrese el vertice origen y destino\n")
try:
path = controller.getShortestPath(catalog, vertices)
print("El camino de menor costo entre los vertices es:")
totalDist = 0
while not stk.isEmpty(path):
step = stk.pop(path)
totalDist += step['weight']
print(step['vertexA'] + "-->" + step['vertexB'] +
" costo: " + str(step['weight']))
print("Total: " + str(totalDist))
except:
print("No existe un camino entre los dos vértices")
else:
print(
"No se han cargado los datos previamente. Carguelos e intente de nuevo."
)
else:
sys.exit(0)
sys.exit(0)
def lstReversePost(self, reversepost):
"""
Retorna una lista con el orden dado por la pila reversepost
"""
lstrp = lt.newList()
while not s.isEmpty(reversepost):
lt.addLast(lstrp, s.pop(reversepost))
return lstrp
def main():
while True:
printMenu()
inputs = input("Seleccione una opción para continuar\n")
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
catalog = initCatalog()
loadData(catalog)
t = tree.size(catalog['date_city_trips'])
print('Arbol numero de nodos', t)
g = controller.countNodesEdgesGraph(catalog)
print('Vertices grafo: ', g[0], ' Ejes grafo: ', g[1])
elif int(inputs[0]) == 2:
city = input('Ingrese nombre de la ciudad: ')
controller.stationsByDockCount(catalog, city)
elif int(inputs[0]) == 3:
dates = input(
'Ingrese las fechas del intervalo (ej: 8/29/2013 1/1/2014) \n')
dat1 = dates.split(" ")[0]
dat2 = dates.split(" ")[1]
r = controller.trips_per_dates(catalog, dat1, dat2)
for city in r:
print(city, r[city])
elif int(inputs[0]) == 4:
n = input("Ingrese el N : ")
f = controller.consulta_temperatures(catalog, n)
maximos = f[0]
minimos = f[1]
print("Los " + n + " con mayor temperatura promedio son :\n")
for i in (maximos['elements']):
print(i)
print("Los " + n + " con menor termperatura promedio son : \n")
for j in (minimos['elements']):
print(j)
elif int(inputs[0]) == 5:
vertices = input(
"Ingrese el vertice origen y destino. (Ejemplo: '48-2014-2-27 66-2014-2-27')\n"
)
path = controller.getShortestPath(catalog, vertices)
if path == 'No hay camino' or path == 'No existen los vértices':
print(path)
else:
print("El camino de menor costo entre los vertices es:")
totalDist = 0
while not stk.isEmpty(path):
step = stk.pop(path)
totalDist += step['weight']
print(step['vertexA'] + "-->" + step['vertexB'] +
" costo: " + str(step['weight']))
print("Total: " + str(totalDist))
else:
sys.exit(0)
sys.exit(0)
def test_error_pop():
"""
Este test busca comprobar que es imposible eliminar un objeto de una pila vacia
"""
stack = st.newStack(list_type)
assert (st.size(stack) == 0)
assert (st.isEmpty(stack))
with pytest.raises(Exception):
st.pop(stack)
def resultado(pila):
if pila == 'No hay camino' or pila == 'No existen los vértices':
print(pila)
else:
print("El camino de menor costo entre los vertices es:")
totalDist = 0
while not stk.isEmpty(pila):
step = stk.pop(pila)
totalDist += step['weight']
print(step['vertexA'] + "-->" + step['vertexB'] + " costo: " +
str(step['weight']))
print("Total: " + str(totalDist))
def test_dijkstra(self):
graph = g.newGraph(7, self.comparenames, directed=True)
g.insertVertex(graph, 'Bogota')
g.insertVertex(graph, 'Yopal')
g.insertVertex(graph, 'Cali')
g.insertVertex(graph, 'Medellin')
g.insertVertex(graph, 'Pasto')
g.insertVertex(graph, 'Barranquilla')
g.insertVertex(graph, 'Manizales')
g.addEdge(graph, 'Bogota', 'Yopal', 2.5)
g.addEdge(graph, 'Bogota', 'Medellin', 0.1)
g.addEdge(graph, 'Bogota', 'Pasto', 16)
g.addEdge(graph, 'Bogota', 'Cali', 3.2)
g.addEdge(graph, 'Cali', 'Bogota', 4.8)
g.addEdge(graph, 'Yopal', 'Medellin', 9.1)
g.addEdge(graph, 'Medellin', 'Pasto', 7.1)
g.addEdge(graph, 'Pasto', 'Bogota', 9.3)
g.addEdge(graph, 'Cali', 'Pasto', 4.7)
g.addEdge(graph, 'Cali', 'Barranquilla', 1.2)
g.addEdge(graph, 'Barranquilla', 'Pasto', 0.0)
dis = dk.newDijkstra(graph, 'Bogota')
path1 = dk.pathTo(dis, 'Pasto')
path2 = dk.pathTo(dis, 'Medellin')
path3 = dk.pathTo(dis, 'Manizales')
totalDist1 = 0
while not stk.isEmpty(path1):
step = stk.pop(path1)
totalDist1 += step['weight']
totalDist2 = 0
while not stk.isEmpty(path2):
step = stk.pop(path2)
totalDist2 += step['weight']
self.assertEqual(totalDist1, 4.4)
self.assertEqual(totalDist2, 0.1)
self.assertIsNone(path3)
def test_push_pop():
"""
Este test prueba que la cola pueda manejar inserciones y eliminaciones de forma correcta siguiendo
un orden establecido, y que no quede referencia al objeto sacado despues de haberlo removido de la
cola
"""
stack = st.newStack(list_type)
assert (st.size(stack) == 0)
assert (st.isEmpty(stack))
st.push(stack, book5)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book6)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book3)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book10)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book1)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book2)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
assert (st.size(stack) == 4)
assert book9 == st.pop(stack)
assert book7 == st.pop(stack)
assert book4 == st.pop(stack)
assert book8 == st.pop(stack)
assert (st.size(stack) == 0)
def test_top_pop():
"""
Este test prueba la creacion de una cola y que el orden de salida sea el correcto para la
estructura en cuestion, y que el tamaño se reduzca para cada salida de objeto
"""
stack = st.newStack(list_type)
assert st.size(stack) == 0
assert st.isEmpty(stack)
st.push(stack, book5)
st.push(stack, book6)
st.push(stack, book3)
st.push(stack, book10)
st.push(stack, book1)
st.push(stack, book2)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
total = st.size(stack)
while not (st.isEmpty(stack)):
top = st.top(stack)
assert (st.pop(stack) == top)
total -= 1
assert (total == st.size(stack))
def getPathBFS(catalog, source, dst):
"""
Retorna el camino, si existe, entre vertice origen y destino
"""
Bfs = BFS(catalog, source)
path = dfs.pathTo(Bfs, dst)
print("vertices: ", source, ", ", dst)
# ejecutar dfs desde source
# obtener el camino hasta dst
# retornar el camino
respuesta = stk.pop(path)
while not stk.isEmpty(path):
paso = stk.pop(path)
respuesta += "--->"
respuesta += paso
return respuesta
def test_sizeStack(self):
"""
"""
self.stack = st.newStack(self.list_type)
self.assertEqual(st.size(self.stack), 0)
self.assertTrue(st.isEmpty(self.stack))
st.push(self.stack, self.movie5)
st.push(self.stack, self.movie6)
st.push(self.stack, self.movie3)
st.push(self.stack, self.movie10)
st.push(self.stack, self.movie1)
st.push(self.stack, self.movie2)
st.push(self.stack, self.movie8)
st.push(self.stack, self.movie4)
st.push(self.stack, self.movie7)
st.push(self.stack, self.movie9)
self.assertEqual(st.size(self.stack), 10)
def test_sizeStack (self):
"""
"""
self.stack = st.newStack(self.list_type)
self.assertEqual (st.size(self.stack), 0)
self.assertTrue (st.isEmpty(self.stack))
st.push (self.stack, self.book5)
st.push (self.stack, self.book6)
st.push (self.stack, self.book3)
st.push (self.stack, self.book10)
st.push (self.stack, self.book1)
st.push (self.stack, self.book2)
st.push (self.stack, self.book8)
st.push (self.stack, self.book4)
st.push (self.stack, self.book7)
st.push (self.stack, self.book9)
self.assertEqual (st.size(self.stack), 10)
def test_sizeStack():
"""
Se prueba la creacion de una cola y la relacion con el tamaño al ingresar datos
"""
stack = st.newStack(list_type)
assert (st.size(stack) == 0)
assert (st.isEmpty(stack))
st.push(stack, book5)
st.push(stack, book6)
st.push(stack, book3)
st.push(stack, book10)
st.push(stack, book1)
st.push(stack, book2)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
assert st.size(stack) == 10
def main():
while True:
printMenu()
inputs = input("Seleccione una opción para continuar\n")
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
catalog = initCatalog()
loadData(catalog)
elif int(inputs[0]) == 2:
verticesNum, edgesNum = controller.countNodesEdges(catalog)
print("El grafo tiene: ", verticesNum, " nodos y", edgesNum,
" enlaces")
elif int(inputs[0]) == 3: #Requerimento 3
vertices = input("Ingrese el vertice origen y destino\n")
path = controller.getShortestPath(catalog, vertices)
print("El camino de menor costo entre los vertices es:")
totalDist = 0
if path:
while not stk.isEmpty(path):
step = stk.pop(path)
totalDist += step['weight']
print(step['vertexA'] + "-->" + step['vertexB'] +
" costo: " + str(step['weight']))
print("Total: " + str(totalDist))
elif int(inputs[0] == 4): #Requerimento 1
ccs = controller.countCC(catalog)
print("El grafo tiene :", ccs, 'componentes conectados')
elif int(inputs[0] == 5): #Requerimento 2
vertices = input("Ingrese el vertice origen y destino\n")
lst = controller.getPath(catalog, vertices)
if lst:
print("El camino entre los vertices es:", lst)
else:
print("No hay camino")
elif int(inputs[0] == 6): #Requerimento 4
vertices = input("Ingrese el vertice origen y destino\n")
leastPath = controller.getPathLeastEdges(catalog, vertices)
if leastPath:
print("El camino más corto entre los vértices es: ", leastPath)
else:
sys.exit(0)
sys.exit(0)
def main():
while True:
printMenu()
inputs = input("Seleccione una opción para continuar\n")
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
catalog = initCatalog()
loadData(catalog)
elif int(inputs[0]) == 2: #Requerimento 1
city = input("Ingrese el nombre de la ciudad que desea consultar")
controller.mostCapacity(catalog, city, 3)
print("para cada estación se indica: ('capacidad', 'id')")
elif int(inputs[0]) == 3: #Requerimento 2
dates = input(
"Ingrese las fechas a consultar separadas por un espacio: ")
trips = controller.tripCityforDates(catalog, dates)
print(trips)
elif int(inputs[0]) == 4: #Requerimento 3
number = int(
input(
"Ingrese un número n para obtener los n días con mayor y menor temperatura y sus viajes: "
))
tripsTempDate = controller.tripsPerTemperatureDate(catalog, number)
print(
"Los días con mayor y menor temperatura tienen los siguientes viajes: ",
tripsTempDate)
elif int(inputs[0]) == 5: #Requerimento 4
vertices = input("Ingrese el vertice origen y destino\n")
path = controller.getShortestPath(catalog, vertices)
print("El camino de menor costo entre los vertices es:")
totalDist = 0
if path:
while not stk.isEmpty(path):
step = stk.pop(path)
totalDist += step['weight']
print(step['vertexA'] + "-->" + step['vertexB'] +
" costo: " + str(step['weight']))
print("Total: " + str(totalDist))
else:
sys.exit(0)
sys.exit(0)
def main():
while True:
printMenu()
inputs = input("Seleccione una opción para continuar\n")
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
catalog = initCatalog()
loadData(catalog)
elif int(inputs[0]) == 2:
city = input("Digite la ciudad que desea buscar: ")
controller.Requerimiento1(catalog, city)
elif int(inputs[0]) == 3:
date1 = input(
"Digite la fecha de inicio que desea buscar (mes/día/año): ")
date2 = input(
"Digite la fecha de finalización que desea buscar (mes/día/año): "
)
print(controller.Requerimiento2(catalog, date1, date2))
elif int(inputs[0]) == 4:
n = int(input("Digite el N que desea buscar: "))
print(controller.Requerimiento3(catalog, n))
elif int(inputs[0]) == 5:
vertices = input("Ingrese el vertice origen y destino\n")
try:
path = controller.getShortestPath(catalog, vertices)
print("El camino de menor costo entre los vertices es:")
totalDist = 0
while not stk.isEmpty(path):
step = stk.pop(path)
totalDist += step['weight']
print(step['vertexA'] + "-->" + step['vertexB'] +
" costo: " + str(step['weight']))
print("Total: " + str(totalDist))
except:
print("No existe un camino entre los dos vértices")
else:
sys.exit(0)
sys.exit(0)
def test_infoElements():
"""
Este test busca confirmar que los datos se almacenen de forma correcta y que
sean los valores correctos en el orden apropiado de la estructura.
"""
stack = st.newStack(list_type)
assert (st.size(stack) == 0)
assert (st.isEmpty(stack))
st.push(stack, book5)
st.push(stack, book6)
st.push(stack, book3)
st.push(stack, book10)
st.push(stack, book1)
st.push(stack, book2)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
elem = st.top(stack)
assert (st.size(stack) == 10)
assert (elem == book9)
elem = st.pop(stack)
assert (st.size(stack) == 9)
assert (elem == book9)
elem = st.pop(stack)
assert (st.size(stack) == 8)
assert (elem == book7)
elem = st.top(stack)
assert (st.size(stack) == 8)
assert (elem == book4)
st.push(stack, book9)
assert (st.size(stack) == 9)
elem = st.top(stack)
assert (elem == book9)
def test_infoElements (self):
"""
"""
self.stack = st.newStack(self.list_type)
self.assertEqual (st.size(self.stack), 0)
self.assertTrue (st.isEmpty(self.stack))
st.push (self.stack, self.book5)
st.push (self.stack, self.book6)
st.push (self.stack, self.book3)
st.push (self.stack, self.book10)
st.push (self.stack, self.book1)
st.push (self.stack, self.book2)
st.push (self.stack, self.book8)
st.push (self.stack, self.book4)
st.push (self.stack, self.book7)
st.push (self.stack, self.book9)
elem = st.top (self.stack)
self.assertEqual (st.size(self.stack), 10)
self.assertDictEqual (elem, self.book9)
elem = st.pop (self.stack)
self.assertEqual (st.size(self.stack), 9)
self.assertDictEqual (elem, self.book9)
elem = st.pop (self.stack)
self.assertEqual (st.size(self.stack), 8)
self.assertDictEqual (elem, self.book7)
elem = st.top (self.stack)
self.assertEqual (st.size(self.stack), 8)
self.assertDictEqual (elem, self.book4)
st.push (self.stack, self.book9)
self.assertEqual (st.size(self.stack), 9)
elem = st.top (self.stack)
self.assertDictEqual (elem, self.book9)
def test_infoElements(self):
"""
"""
self.stack = st.newStack(self.list_type)
self.assertEqual(st.size(self.stack), 0)
self.assertTrue(st.isEmpty(self.stack))
st.push(self.stack, self.movie5)
st.push(self.stack, self.movie6)
st.push(self.stack, self.movie3)
st.push(self.stack, self.movie10)
st.push(self.stack, self.movie1)
st.push(self.stack, self.movie2)
st.push(self.stack, self.movie8)
st.push(self.stack, self.movie4)
st.push(self.stack, self.movie7)
st.push(self.stack, self.movie9)
elem = st.top(self.stack)
self.assertEqual(st.size(self.stack), 10)
self.assertDictEqual(elem, self.movie9)
elem = st.pop(self.stack)
self.assertEqual(st.size(self.stack), 9)
self.assertDictEqual(elem, self.movie9)
elem = st.pop(self.stack)
self.assertEqual(st.size(self.stack), 8)
self.assertDictEqual(elem, self.movie7)
elem = st.top(self.stack)
self.assertEqual(st.size(self.stack), 8)
self.assertDictEqual(elem, self.movie4)
st.push(self.stack, self.movie9)
self.assertEqual(st.size(self.stack), 9)
elem = st.top(self.stack)
self.assertDictEqual(elem, self.movie9)
def printTopological(self, reversepost):
print('se pueden ver los cursos en el siguiente orden:')
while not s.isEmpty(reversepost):
print(s.pop(reversepost))
