def afectedCountries (analyzer, vertex):
adjacentedges = gr.adjacentEdges(analyzer['connections'], vertex)
map = mp.newMap(numelements=100,maptype='PROBING')
lstedges = adjacentedges.copy()
i = 1
while i <= lt.size(lstedges):
edge = lt.getElement(lstedges, i)
pais = edge['vertexB'].split(',')
if len(pais) > 3:
pais = pais[len(pais)-1]
else:
pais = pais[0]
contains = mp.contains(map, pais)
if contains:
entry = mp.get(map, pais)
entry = me.getValue(entry)
if e.weight(edge) < entry[0]:
mp.put(map, pais, (e.weight(edge), i))
lt.deleteElement(lstedges, entry[1])
else:
lt.deleteElement(lstedges, i)
else:
mp.put(map, pais, (e.weight(edge), i))
i += 1
orderededges = mergeSortEdges(lstedges, lt.size(lstedges))[0]
return (adjacentedges, orderededges)
def scan(graph, search, vertex):
"""
Args:
search: La estructura de busqueda
vertex: El vertice destino
Returns:
El costo total para llegar de source a
vertex. Infinito si no existe camino
Raises:
Exception
"""
try:
map.put(search['marked'], vertex, True)
edges = g.adjacentEdges(graph, vertex)
for edge in lt.iterator(edges):
w = e.other(edge, vertex)
if (not map.get(search['marked'], w)['value']):
if (e.weight(edge) < map.get(search['distTo'], w)['value']):
map.put(search['distTo'], w, e.weight(edge))
map.put(search['edgeTo'], w, edge)
if (pq.contains(search['pq'], w)):
pq.decreaseKey(search['pq'], w,
map.get(search['distTo'], w)['value'])
else:
pq.insert(search['pq'], w,
map.get(search['distTo'], w)['value'])
return search
except Exception as exp:
error.reraise(exp, 'bellman:disto')
def relax(search, edge):
"""
Relaja el peso de los arcos del grafo con la
nueva de un nuevo arco
Args:
search: La estructura de busqueda
edge: El nuevo arco
Returns:
El grafo con los arcos relajados
Raises:
Exception
"""
try:
v = e.either(edge)
w = e.other(edge, v)
visited_v = map.get(search['visited'], v)['value']
visited_w = map.get(search['visited'], w)['value']
distw = visited_w['distTo']
distv = visited_v['distTo'] + e.weight(edge)[0]
if (visited_w is None) or (distw > distv):
distow = visited_v['distTo'] + e.weight(edge)[0]
map.put(search['visited'], w, {
'marked': True,
'edgeTo': edge,
'distTo': distow
})
if iminpq.contains(search['iminpq'], w):
iminpq.decreaseKey(search['iminpq'], w, distow)
else:
iminpq.insert(search['iminpq'], w, distow)
return search
except Exception as exp:
error.reraise(exp, 'dks:relax')
def PaisesAfectados(catalog, nombreLanding):
landing = mp.get(catalog["LandingPointN"], nombreLanding)
listaPaises = "NE"
if landing != None:
#listaPaises = lt.newList('ARRAY_LIST')
tablitaPaises = mp.newMap(numelements=10,
maptype='PROBING',
comparefunction=compareCountryNames)
landing = me.getValue(landing)
datosLanding = lt.getElement(
me.getValue(mp.get(catalog["LandingPointI"], landing))['lstData'],
1)
paisLanding = datosLanding["name"].split(",")
paisLanding = paisLanding[len(paisLanding) - 1].strip()
h = paisLanding
edge = gr.getEdge(catalog["connectionsDistance"], paisLanding, landing)
peso = e.weight(edge) / 1000
#lt.addLast(listaPaises,paisLanding)
mp.put(tablitaPaises, paisLanding, peso)
adyacentes = gr.adjacentEdges(catalog["connectionsDistance"], landing)
for arco in lt.iterator(adyacentes):
OtroVertex = e.other(arco, landing)
if not mp.contains(catalog['countriesInfo'], OtroVertex):
adyacentes2 = gr.adjacentEdges(catalog["connectionsDistance"],
OtroVertex)
for arco2 in lt.iterator(adyacentes2):
OtroVertex2 = e.other(arco2, OtroVertex)
if not mp.contains(catalog['countriesInfo'],
OtroVertex2) and OtroVertex2 != landing:
peso = e.weight(arco2) / 1000
id = OtroVertex2.split("*")[0]
datosLanding = lt.getElement(
me.getValue(mp.get(catalog["LandingPointI"],
id))['lstData'], 1)
paisLanding = datosLanding["name"].split(",")
paisLanding = paisLanding[len(paisLanding) - 1].strip()
#if lt.isPresent(listaPaises,paisLanding)==0:
# lt.addLast(listaPaises,paisLanding)
pais = mp.get(tablitaPaises, paisLanding)
if pais != None:
pais = me.getValue(pais)
if (peso < pais):
mp.put(tablitaPaises, paisLanding, peso) #ACA
else:
mp.put(tablitaPaises, paisLanding, peso) #ACA
#heap = pq.newMinPQ(cmpfunction=compareDistance)
listaPaises = lt.newList('ARRAY_LIST')
for pais in lt.iterator(mp.keySet(tablitaPaises)):
elemento = me.getValue(mp.get(tablitaPaises, pais))
#pq.insert(heap,(pais,elemento))
lt.addLast(listaPaises, (pais, elemento))
merge.sort(listaPaises, compareDistance)
return listaPaises
def req4(citibike, resis, inicio):
"William Mendez"
pendientes = [] #str del id
encontrados = {} #{llegada: (origen, duracion)}
primeros = gr.adjacents(citibike['graph'], inicio)
iterator = it.newIterator(primeros)
while it.hasNext(iterator):
element = it.next(iterator)
# print(element)
durac = ed.weight(gr.getEdge(citibike['graph'], inicio, element)) / 60
if durac <= resis:
encontrados[element] = (inicio, round(durac, 2))
pendientes.append(element)
while len(pendientes) > 0:
for i in pendientes:
adya = gr.adjacents(citibike['graph'], i)
if adya['size'] != 0:
# print(adya)
iterator = it.newIterator(adya)
while it.hasNext(iterator):
element = it.next(iterator)
# print(element)
if element not in encontrados.keys() and \
element not in pendientes and element != inicio:
durac = 0
llega = i
# print(i, element)
while llega != inicio:
# print(durac)
durac += encontrados[llega][1]
llega = encontrados[llega][0]
# print(durac)
relativ = ed.weight(
gr.getEdge(citibike['graph'], i, element)) / 60
# print(durac, relativ, durac + relativ, resis)
if (durac + relativ) <= resis:
encontrados[element] = (i, round(relativ, 2))
pendientes.append(element)
pendientes.remove(i)
# print(len(pendientes))
# print(encontrados)
return encontrados
def weightMST(graph, search):
weight = 0.0
# edgesMST(graph, search)
edges = search['mst']
for edge in lt.iterator(edges):
weight = weight + e.weight(edge)
return weight
def dfsVertex(search, graph, vertex):
"""
Funcion auxiliar para calcular un recorrido DFS
Args:
search: Estructura para almacenar el recorrido
vertex: Vertice de inicio del recorrido.
Returns:
Una estructura para determinar los vertices
conectados a source
Raises:
Exception
"""
try:
result = False
adjlst = g.adjacents(graph, vertex)
adjslstiter = it.newIterator(adjlst)
while (it.hasNext(adjslstiter)):
w = it.next(adjslstiter)
if w == vertex:
result = True
visited = map.get(search['visited'], w)
if visited is None:
map.put(
search['visited'], w, {
'marked': True,
'edgeTo': vertex,
'peso': edge.weight(gr.getEdge(graph, vertex, w))
})
dfsVertex(search, graph, w)
return (search, result)
except Exception as exp:
error.reraise(exp, 'dfs:dfsVertex')
def Dijkstra(graph, source, inicio, fin):
"""
Implementa el algoritmo de Dijkstra
Args:
graph: El grafo de busqueda
source: El vertice de inicio
Returns:
Un nuevo grafo vacío
Raises:
Exception
"""
try:
search = initSearch(graph, source)
while not iminpq.isEmpty(search['iminpq']):
v = iminpq.delMin(search['iminpq'])
edges = g.adjacentEdges(graph, v)
if edges is not None:
edgesiter = it.newIterator(edges)
while (it.hasNext(edgesiter)):
edge = it.next(edgesiter)
peso = e.weight(edge)
v = e.either(edge)
if v == source:
if peso[0] < fin and peso[0] > inicio:
relax(search, edge)
else:
relax(search, edge)
return search
except Exception as exp:
error.reraise(exp, 'dks:dijkstra')
def relax(graph, search, v):
"""
Relaja el peso de los arcos del grafo
Args:
search: La estructura de busqueda
v: Vertice desde donde se relajan los pesos
Returns:
El grafo con los arcos relajados
Raises:
Exception
"""
try:
edges = g.adjacentEdges(graph, v)
if edges is not None:
for edge in lt.iterator(edges):
v = e.either(edge)
w = e.other(edge)
distv = map.get(search['distTo'], v)['value']
distw = map.get(search['distTo'], w)['value']
distweight = distv + e.weight(edge)
if (distw > distweight):
map.put(search['distTo'], w, distweight)
map.put(search['edgeTo'], w, edge)
if (not map.get(search['onQ'], w)['value']):
q.enqueue(search['qvertex'], w)
map.put(search['onQ'], w, True)
cost = search['cost']
if ((cost % g.numVertices(graph)) == 0):
findneg = findNegativeCycle(graph, search)
if (hasNegativecycle(findneg)):
return
search['cost'] = cost + 1
return search
except Exception as exp:
error.reraise(exp, 'bellman:relax')
def GrafosPorCiclo(analyzer, origen, VDC):
"""
Genera un grafo por cada ciclo diferente relacionado al origen y los añade a
GPCC (diccionario)
"""
#GPCC = Grafos Por Cada Ciclo
GPCC = {}
if VDC == False:
return False
else:
for Valor in VDC:
Cierre = False
GPCC[Valor] = gr.newGraph(datastructure="ADJ_LIST",
directed=True,
size=6,
comparefunction=comparer)
gr.insertVertex(GPCC[Valor], origen)
actual = origen
mismo = origen
Adjacentes = adj.adjacents(analyzer["graph"], actual)
Adjacentes["cmpfunction"] = comparador
while Cierre == False:
a = it.newIterator(VDC[Valor])
while it.hasNext(a):
b = it.next(a)
if actual != mismo:
Adjacentes = adj.adjacents(analyzer["graph"], actual)
Adjacentes["cmpfunction"] = comparador
mismo = actual
if not gr.containsVertex(GPCC[Valor], b):
if lt.isPresent(Adjacentes, origen) != 0 and actual != origen and b != origen:
gr.insertVertex(GPCC[Valor], b)
Tartalia = gr.getEdge(analyzer["graph"], actual, origen)
Peso = int(ed.weight(Tartalia)/Tartalia["Repeticiones"])
adj.addEdge(GPCC[Valor], actual, origen, Peso)
actual = b
Cierre = True
elif lt.isPresent(Adjacentes, b) != 0 and b != origen:
gr.insertVertex(GPCC[Valor], b)
Tartalia = gr.getEdge(analyzer["graph"], actual, b)
Peso = int(ed.weight(Tartalia)/Tartalia["Repeticiones"])
adj.addEdge(GPCC[Valor], actual, b, Peso)
actual = b
elif actual == origen and lt.size(VDC[Valor]) == 1:
Cierre = True
return GPCC
def buscarMayor(search):
buscar = 0
edges = search["mst"]
for edge in lt.iterator(edges):
peso = e.weight(edge)
if peso > buscar:
buscar = peso
return buscar
def bfsVertex(search, graph, source, time, camino):
"""
Funcion auxiliar para calcular un recorrido BFS
Args:
search: Estructura para almacenar el recorrido
vertex: Vertice de inicio del recorrido.
Returns:
Una estructura para determinar los vertices
conectados a source
Raises:
Exception
"""
try:
adjsqueue = queue.newQueue()
queue.enqueue(adjsqueue, source)
while not (queue.isEmpty(adjsqueue)):
lista = []
tiempo = time
vertex = queue.dequeue(adjsqueue)
visited_v = map.get(search['visited'], vertex)['value']
adjslst = g.adjacents(graph, vertex)
adjslstiter = it.newIterator(adjslst)
while (it.hasNext(adjslstiter)):
w = it.next(adjslstiter)
visited_w = map.get(search['visited'], w)
if ed.weight(g.getEdge(graph, vertex, w)) <= tiempo:
lista.append(w)
tiempo = tiempo - ed.weight(g.getEdge(graph, vertex, w))
else:
camino.append(lista)
if visited_w is None:
dist_to_w = visited_v['distTo'] + 1
visited_w = {
'marked': True,
'edgeTo': vertex,
"distTo": dist_to_w
}
map.put(search['visited'], w, visited_w)
queue.enqueue(adjsqueue, w)
return search
except Exception as exp:
error.reraise(exp, 'bfs:bfsVertex')
def buscarMenor(search):
buscar = math.inf
edges = search["mst"]
#dicc = {}
for edge in lt.iterator(edges):
peso = float(e.weight(edge))
#dicc[peso] = None
if peso != 1 and peso != 0 and peso < buscar:
buscar = peso
#print(dicc.keys())
return buscar
def addConnection(graph, origin, destination, duration):
"""
Adiciona un arco entre dos community areas
"""
edge = gr.getEdge(graph, origin, destination)
if edge is None:
gr.addEdge(graph, origin, destination, duration)
else:
weight = e.weight(edge)
prom = (duration + weight)/2
edge['weight'] = prom
return graph
def addConnection(analyzer, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(analyzer["trips"], origin, destination)
if edge is None:
gr.addEdge(analyzer["trips"], origin, destination, duration)
else:
weight = e.weight(edge)
prom = (duration + weight) / 2
edge['weight'] = prom
return analyzer
def addConnection(citibike, origin, destination, duration):
"""
Adiciona un arco entre dos estaciones
"""
edge = gr.getEdge(citibike['graph'], origin, destination)
if edge is None:
gr.addEdge(citibike['graph'], origin, destination, duration)
else:
prev_duration = int(ed.weight(edge))
duration += prev_duration
ed.updateWeight(edge, duration)
return citibike
def updateRoute(trip: dict, DataBase: dict) -> None:
startId = int(trip["start station id"])
endId = int(trip["end station id"])
tripTime = int(trip["tripduration"])
edgeRoute = graph.getEdge(DataBase['graph'], startId, endId)
if edgeRoute is None:
weight = Structure.newWeight()
graph.addEdge(DataBase['graph'], startId, endId, weight)
edgeRoute = graph.getEdge(DataBase['graph'], startId, endId)
weight = edge.weight(edgeRoute)
weight['time'] = aveTime(weight, tripTime)
weight['users'] += 1
def findNegativeCycle(graph, search):
"""
Identifica ciclos negativos en el grafo
"""
try:
vertices = g.vertices(graph)
for vert in lt.iterator(vertices):
edge = map.get(search['edgeTo'], vert)
if (edge is not None):
edge = edge['value']
g.addEdge(search['spt'], e.either(edge), e.other(edge),
e.weight(edge))
finder = c.DirectedCycle(search['spt'])
search['cycle'] = not st.isEmpty(c.cycle(finder))
return search
except Exception as exp:
error.reraise(exp, 'bellman:pathto')
def caminoMin(caminosMinimos, pais1, pais2):
""" Se consigue la distancia y el camino que conecta la fuente del grafo Caminos minimos con el Pais2.
Si la distancia es infinito, lo cual indica que no hay camino, esta se remplaza por -1.
#PROXIMAMENTE: Pasar el camino a una lista para que sea facil de imprimir en el view"""
caminos = lt.newList('ARRAY_LIST', cmpfunction=compareCountryNames)
camino = djk.pathTo(caminosMinimos, pais2)
distancia = djk.distTo(caminosMinimos, pais2)
if distancia == math.inf:
distancia = -1
else:
for elemento in lt.iterator(camino):
dato = lt.newList('ARRAY_LIST')
land1 = e.either(elemento)
peso = e.weight(elemento)
land2 = e.other(elemento, e.either(elemento))
lt.addLast(dato, land1)
lt.addLast(dato, peso)
lt.addLast(dato, land2)
lt.addLast(caminos, dato)
return caminos, distancia
def Requirement3(analyzer, country1, country2):
tracemalloc.start()
delta_time = -1.0
delta_memory = -1.0
start_time = getTime()
start_memory = getMemory()
capital1 = (mp.get(analyzer['countries_map'],
country1)['value'])['CapitalName']
capital2 = (mp.get(analyzer['countries_map'],
country2)['value'])['CapitalName']
analyzer['paths'] = djk.Dijkstra(
analyzer['connections_origin_destination'], capital1)
path = djk.pathTo(analyzer['paths'], capital2)
distance = djk.distTo(analyzer['paths'], capital2)
listKm = lt.newList('ARRAY_LIST')
iterator1 = it.newIterator(path)
while it.hasNext(iterator1):
component = it.next(iterator1)
vertexA = edge.either(component)
vertexB = edge.other(component, vertexA)
weight = edge.weight(component)
string = 'Ir ' + str(weight) + ' Km desde ' + vertexA + ' a ' + vertexB
lt.addLast(listKm, string)
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
return (listKm, distance, delta_time, delta_memory)
def TiempoNecesariomod(analyzer, GPCC, limites):
if GPCC == False:
return False
else:
Ideal = {}
Pesos = {}
for A in GPCC:
Pesos[A] = 0
n = it.newIterator(gr.edges(GPCC[A]))
if it.hasNext(n):
d = it.next(n)
Pesos[A] += ed.weight(d)
LimiteInferior = 0*60
LimiteSuperior = limites*60
for B in Pesos:
if Pesos[B] >= LimiteInferior and Pesos[B] <= LimiteSuperior:
Ideal[B] = GPCC[B]
if len(Ideal) == 0:
return "Vacio"
else:
return Ideal
def test_edgeMethods(graph):
edge = e.newEdge('Bogota', 'Cali')
assert 'Bogota' == e.either(edge)
assert 'Cali' == e.other(edge, e.either(edge))
assert e.weight(edge) == 0
def cmpKm(edge1, edge2):
return float(e.weight(edge1)) > float(e.weight(edge2))
def circulargraph(analyzer, StartStationid, avaibleTimemin, avaibleTimemax):
r = {"R_Especifico": {}}
rutas = 0
totalrutas = -1
Kosaraju = connectedComponents(analyzer)
verticeslst = gr.vertices(analyzer['graph'])
vertices = it.newIterator(verticeslst)
bfs_startstation = dfs.DepthFirstSearch(analyzer['graph'], StartStationid)
while it.hasNext(vertices):
time = -20
vertice = it.next(vertices)
if sameCC(analyzer, StartStationid, vertice):
totalrutas += 1
if (gr.getEdge(analyzer['graph'], vertice,
StartStationid)) != None:
tiempo_vuelta = e.weight(
gr.getEdge(analyzer['graph'], vertice, StartStationid))
tiempo_vuelta = tiempo_vuelta
pila_ida = (dfs.pathTo(bfs_startstation, vertice))
v1 = st.pop(pila_ida)
time += (20 * st.size(pila_ida))
while not st.isEmpty(pila_ida):
v2 = st.pop(pila_ida)
time += e.weight(gr.getEdge(analyzer['graph'], v1, v2))
v1 = v2
if time / 60 > avaibleTimemax:
break
else:
bfs_backstation = dfs.DepthFirstSearch(analyzer['graph'],
vertice)
pila_ida = (dfs.pathTo(bfs_startstation, vertice))
pila_vuelta = (dfs.pathTo(bfs_backstation, vertice))
v1v = st.pop(pila_vuelta)
v1 = st.pop(pila_ida)
time += (20 * (st.size(pila_ida) + st.size(pila_vuelta)))
while not st.isEmpty(pila_ida):
v2 = st.pop(pila_ida)
time += e.weight(gr.getEdge(analyzer['graph'], v1, v2))
v1 = v2
if time / 60 > avaibleTimemax:
break
while not st.isEmpty(pila_vuelta):
v2v = st.pop(pila_vuelta)
time += e.weight(gr.getEdge(analyzer['graph'], v1v, v2v))
v1v = v2v
if time / 60 > avaibleTimemax:
break
time = round(time / 60, 2)
if time >= avaibleTimemin and time <= avaibleTimemax:
rutas += 1
StartStationName = getName(analyzer["stationinfo"],
StartStationid)
FinalStationName = getName(analyzer["stationinfo"], vertice)
r["R_Especifico"][rutas] = {
"Nombre_station_Inicio": StartStationName,
"Nombre_station_Final": FinalStationName,
"tiempo en min ": time
}
elif sameCC(analyzer, StartStationid, vertice) == None:
pass
return (totalrutas, rutas, r)
for value in lt.iterator(result[0][0]):
print(value)
print('El anterior landing point tiene un total de ', result[0][1],
' interconexiones con cables')
print("\nTiempo [ms]: ", f"{result[1][0]:.3f}", " || ",
"Memoria [kB]: ", f"{result[1][1]:.3f}")
elif int(inputs[0]) == 4:
origin = input('Ingrese el pais de origen: ')
destination = input('Ingrese el pais de destino: ')
result = controller.requerimiento3(analyzer, origin, destination)
if result[0] is not None:
distance = 0
while (not stack.isEmpty(result[0])):
edge = stack.pop(result[0])
distance += e.weight(edge)
print(edge)
print('La distancia es de ', distance, ' Km')
else:
print('No es posible establecer una conexion')
print("\nTiempo [ms]: ", f"{result[1][0]:.3f}", " || ",
"Memoria [kB]: ", f"{result[1][1]:.3f}")
vermap = input('Desea observar el camino grafica en el mapa?')
if vermap == 'si':
webbrowser.open('mapa.html')
elif int(inputs[0]) == 5:
result = controller.requerimiento4(analyzer)
distance = 0
while (not lt.isEmpty(result[0][0])):
edge = lt.removeLast(result[0][0])
