def newAnalyzer():
analyzer = {
'vertices': None,
'element': None,
'camino': None,
'landing_names_id': None,
'info_landings': None,
'landing_points': None,
'countries': None,
'connections': None,
'connections_directed': None,
'cities_country': None
}
analyzer['vertices'] = lt.newList()
analyzer['landing_points'] = om.newMap()
analyzer['landing_names_id'] = mp.newMap()
analyzer['countries'] = mp.newMap(maptype='PROBING')
analyzer['connections'] = gr.newGraph(datastructure='ADJ_LIST',
directed=False)
analyzer['connections_directed'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True)
analyzer['cities_country'] = mp.newMap(maptype='PROBING')
analyzer['capitals'] = mp.newMap(maptype='PROBING')
return analyzer
def newAnalyzer():
analyzer = {'LandingPointO': None, 'LandingPointD': None, 'CableDistance': None, 'CableCapacity': None, 'Countries': None}
analyzer['LandingPointO'] = mp.newMap(numelements=1300, maptype='PROBING', comparefunction=cmpCountriesbyNames)
analyzer['LandingPointD'] = mp.newMap(numelements=1300, maptype='PROBING', comparefunction=cmpCountriesbyNames)
analyzer['CableDistance'] = gr.newGraph(datastructure='ADJ_LIST', directed=True, size=3500, comparefunction=cmpCountriesbyNames)
analyzer['CableCapacity'] = gr.newGraph(datastructure='ADJ_LIST', directed=True, size=3500, comparefunction=cmpCountriesbyNames)
analyzer['Countries'] = mp.newMap(numelements=300, maptype='PROBING', comparefunction=cmpCountriesbyNames)
return analyzer
def newCatalog():
"""
Contiene 4 tablas de hash que contiene las informacion del CSV
Un grafo que contiene la coneccion entre landing_point
"""
catalog = {
'map_landing_points': None,
'map_countries': None,
'map_connections': None,
'capitals': None,
'vertex_capitals': None,
'graph_landing_points': None
}
catalog['map_landing_points'] = mp.newMap(numelements=3200,
maptype='PROBING',
loadfactor=0.4)
catalog['map_countries'] = mp.newMap(numelements=650,
maptype='PROBING',
loadfactor=0.4)
catalog['map_connections'] = mp.newMap(numelements=1200,
maptype='PROBING',
loadfactor=0.4)
catalog['capitals'] = mp.newMap(numelements=650,
maptype='PROBING',
loadfactor=0.4)
catalog['vertex_capitals'] = mp.newMap(numelements=5500,
maptype='PROBING',
loadfactor=0.4)
catalog['graph_landing_points'] = gr.newGraph(datastructure='ADJ_LIST',
directed=False,
size=5000)
return catalog
def catalog():
catalog = {'landingpoints': None,
'connections': None,
'countries': None
}
catalog['landingpoints'] = mp.newMap(numelements=14000,
maptype='PROBING',
loadfactor=0.5,
comparefunction=compareLandingpIds)
catalog['connections']=gr.newGraph(datastructure='ADJ_LIST',
directed= False,
size=400,
comparefunction=compareLandingpIds)
catalog['countries']=mp.newMap(numelements=14000,
maptype='PROBING',
loadfactor=0.5,
comparefunction=compareLandingpIds)
catalog['reqc']=lt.newList(datastructure='SINGLE_LINKED')
catalog['cities']=mp.newMap(numelements=14000,
maptype='PROBING',
loadfactor=0.5,)
catalog['lpkeys']=mp.newMap(numelements=14000,
maptype='PROBING',
loadfactor=0.5,)
catalog['cable']=mp.newMap(numelements=14000,
maptype='PROBING',
loadfactor=0.5,)
return catalog
def graph():
graph = g.newGraph(size=7, comparefunction=compareVertices, directed=True)
g.insertVertex(graph, 'Bogota')
g.insertVertex(graph, 'Duitama')
g.insertVertex(graph, 'Armenia')
g.insertVertex(graph, 'Honda')
g.insertVertex(graph, 'Espinal')
g.insertVertex(graph, 'Florencia')
g.insertVertex(graph, 'Cali')
g.addEdge(graph, 'Bogota', 'Duitama', 3.5)
g.addEdge(graph, 'Bogota', 'Honda', 3)
g.addEdge(graph, 'Bogota', 'Espinal', 4.5)
g.addEdge(graph, 'Duitama', 'Armenia', 1)
g.addEdge(graph, 'Honda', 'Duitama', 1)
g.addEdge(graph, 'Honda', 'Espinal', 1)
g.addEdge(graph, 'Honda', 'Armenia', 2.5)
g.addEdge(graph, 'Honda', 'Florencia', 5.5)
g.addEdge(graph, 'Espinal', 'Florencia', 2.4)
g.addEdge(graph, 'Honda', 'Cali', 6)
g.addEdge(graph, 'Florencia', 'Cali', 1)
g.addEdge(graph, 'Armenia', 'Cali', 4)
return graph
def newChicagoAnalyzer():
"""
Funcion para inicializar el analyzer
"""
chicagoAnalyzer = {'taxi': None, 'communityTrip': None, 'company': None}
chicagoAnalyzer['taxi'] = m.newMap(numelements=100,
comparefunction=compareComm)
chicagoAnalyzer['communityTrip'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=2000,
comparefunction=compareComm)
chicagoAnalyzer['company'] = m.newMap(numelements=50,
comparefunction=compareComm)
chicagoAnalyzer['timeTrip'] = om.newMap(omaptype='BST',
comparefunction=compareID)
chicagoAnalyzer['tripID_edge'] = m.newMap(numelements=2000,
comparefunction=compareComm)
chicagoAnalyzer['dateIndex'] = om.newMap(omaptype='BST',
comparefunction=compareDates)
chicagoAnalyzer['numServicios'] = 0
return chicagoAnalyzer
def initDataBase() -> dict:
dataBase = {
'graph': graph.newGraph('ADJ_LIST', True, 14000, compareId),
'station': map.newMap(878756, 878777, 'CHAINING', 1.5, compareId),
'trips': 0
}
return dataBase
def graph():
graph = g.newGraph(size=10, directed=True, comparefunction=compareVertices)
g.insertVertex(graph, 'Calculo1')
g.insertVertex(graph, 'Calculo2')
g.insertVertex(graph, 'Diseno1')
g.insertVertex(graph, 'Diseno2')
g.insertVertex(graph, 'Electiva')
g.insertVertex(graph, 'Fisica1')
g.insertVertex(graph, 'Ingles')
g.insertVertex(graph, 'IP1')
g.insertVertex(graph, 'IP2')
g.insertVertex(graph, 'ProyectoFinal')
g.addEdge(graph, 'Calculo1', 'Calculo2')
g.addEdge(graph, 'Calculo2', 'IP2')
g.addEdge(graph, 'Calculo2', 'Fisica1')
g.addEdge(graph, 'Diseno1', 'Diseno2')
g.addEdge(graph, 'Diseno2', 'ProyectoFinal')
g.addEdge(graph, 'Electiva', 'ProyectoFinal')
g.addEdge(graph, 'Fisica1', 'Diseno2')
g.addEdge(graph, 'Ingles', 'ProyectoFinal')
g.addEdge(graph, 'IP1', 'Diseno1')
g.addEdge(graph, 'IP1', 'IP2')
return graph
def reverseGraph(graph):
"""
Retornar el reverso del grafo graph
"""
try:
greverse = g.newGraph(size=g.numVertices(graph),
directed=True,
comparefunction=graph['comparefunction'])
lstvert = g.vertices(graph)
itervert = it.newIterator(lstvert)
while it.hasNext(itervert):
vert = it.next(itervert)
g.insertVertex(greverse, vert)
itervert = it.newIterator(lstvert)
while it.hasNext(itervert):
vert = it.next(itervert)
lstadj = g.adjacents(graph, vert)
iteradj = it.newIterator(lstadj)
while it.hasNext(iteradj):
adj = it.next(iteradj)
g.addEdge(greverse, adj, vert)
return greverse
except Exception as exp:
error.reraise(exp, 'scc:reverse')
def cgraph():
graph = g.newGraph(size=7, comparefunction=compareVertices, directed=True)
g.insertVertex(graph, 'S1')
g.insertVertex(graph, 'S2')
g.insertVertex(graph, 'S3')
g.insertVertex(graph, 'S4')
g.insertVertex(graph, 'S5')
g.insertVertex(graph, 'S6')
g.insertVertex(graph, 'S7')
g.addEdge(graph, 'S1', 'S2', 9)
g.addEdge(graph, 'S1', 'S3', 22)
g.addEdge(graph, 'S2', 'S7', -3)
g.addEdge(graph, 'S3', 'S2', 5)
g.addEdge(graph, 'S3', 'S7', 3)
g.addEdge(graph, 'S3', 'S4', -1)
g.addEdge(graph, 'S3', 'S6', 6)
g.addEdge(graph, 'S3', 'S5', 5.5)
g.addEdge(graph, 'S4', 'S1', 1.5)
g.addEdge(graph, 'S4', 'S5', 0.4)
g.addEdge(graph, 'S5', 'S6', -8)
g.addEdge(graph, 'S7', 'S6', 10)
return graph
def graph():
graph = g.newGraph(size=12, directed=True, comparefunction=compareVertices)
g.insertVertex(graph, 'Pedro')
g.insertVertex(graph, 'Maria')
g.insertVertex(graph, 'Carol')
g.insertVertex(graph, 'Laura')
g.insertVertex(graph, 'Felipe')
g.insertVertex(graph, 'Jose')
g.insertVertex(graph, 'Martin')
g.insertVertex(graph, 'Camila')
g.insertVertex(graph, 'Gloria')
g.insertVertex(graph, 'Luz')
g.insertVertex(graph, 'Tere')
g.insertVertex(graph, 'Susana')
g.addEdge(graph, 'Pedro', 'Jose')
g.addEdge(graph, 'Jose', 'Felipe')
g.addEdge(graph, 'Felipe', 'Laura')
g.addEdge(graph, 'Laura', 'Carol')
g.addEdge(graph, 'Carol', 'Maria')
g.addEdge(graph, 'Maria', 'Pedro')
g.addEdge(graph, 'Camila', 'Jose')
g.addEdge(graph, 'Camila', 'Martin')
g.addEdge(graph, 'Martin', 'Gloria')
g.addEdge(graph, 'Gloria', 'Camila')
g.addEdge(graph, 'Gloria', 'Luz')
g.addEdge(graph, 'Luz', 'Tere')
g.addEdge(graph, 'Tere', 'Susana')
g.addEdge(graph, 'Susana', 'Luz')
return graph
def newAnalyzer():
"""
Inicializa el analizador de conexiones
"""
analyzer = {
'connections': None,
'cablesbylandingpoint': None,
'connectedlandingpoints': None,
'landingpointsbycable': None,
'bandwidthbycable': None,
'landingpointscoords': None,
'landingpointsnames': None,
'countries': None,
'landingpointsbycountry': None,
'vertexscoords': None,
'sccomponents': None,
'minimumcostpaths': None,
'minimumspanningtrees': None,
'minimumjumpspaths': None
}
analyzer['connections'] = gr.newGraph('ADJ_LIST', False, 100000)
analyzer['cablesbylandingpoint'] = mp.newMap(maptype='PROBING')
analyzer['connectedlandingpoints'] = mp.newMap(maptype='PROBING')
analyzer['landingpointsbycable'] = mp.newMap(maptype='PROBING')
analyzer['bandwidthbycable'] = mp.newMap(maptype='PROBING')
analyzer['landingpointscoords'] = mp.newMap(maptype='PROBING')
analyzer['landingpointsnames'] = mp.newMap(maptype='PROBING')
analyzer['countries'] = mp.newMap(maptype='PROBING')
analyzer['landingpointsbycountry'] = mp.newMap(maptype='PROBING')
analyzer['vertexscoords'] = mp.newMap(maptype='PROBING')
return analyzer
def draw_connections(self):
self.connections_map = gp.newGraph(size=lt.size(self.connections_list),
directed=True)
self.add_vertices()
self.add_edges()
if toggle_capitales:
self.add_capitals_edges()
def initSearch(graph, source):
"""
Inicializa la estructura de busqueda y deja
todos los arcos en infinito.
Se inserta en la cola el vertice source
Args:
graph: El grafo a examinar
source: El vertice fuente
Returns:
Estructura de busqueda inicializada
Raises:
Exception
"""
try:
search = {
'source': source,
'edgeTo': None,
'distTo': None,
'qvertex': None,
'onQ': None,
'cost': 0,
'spt': None,
'cycle': False
}
search['edgeTo'] = map.newMap(numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
search['distTo'] = map.newMap(numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
search['onQ'] = map.newMap(numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
search['spt'] = g.newGraph(size=g.numVertices(graph),
directed=True,
comparefunction=graph['comparefunction'])
vertices = g.vertices(graph)
for vert in lt.iterator(vertices):
map.put(search['distTo'], vert, math.inf)
map.put(search['onQ'], vert, False)
g.insertVertex(search['spt'], vert)
newq = q.newQueue()
search['qvertex'] = newq
return search
except Exception as exp:
error.reraise(exp, 'bellman:init')
def newAnalyzer():
""" Inicializa el analizador
"""
try:
analyzer = {
'landingPoints': None,
'landingPointNames': None,
'connections': None,
'arches': None,
'countries': None,
'countriesCodes': None
}
analyzer['landingPoints'] = mp.newMap(
numelements=1280,
maptype='PROBING',
comparefunction=compareLandingPoints)
analyzer['landingPointNames'] = mp.newMap(
numelements=1280,
maptype='PROBING',
comparefunction=compareLandingPointNames)
analyzer['connections'] = gr.newGraph(
datastructure='ADJ_LIST',
directed=True,
size=3300,
comparefunction=compareLandingPoints)
analyzer['arches'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=3300,
comparefunction=compareLandingPoints)
analyzer['countries'] = mp.newMap(numelements=300, maptype='PROBING')
analyzer['countriesCodes'] = mp.newMap()
return analyzer
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def new_model() -> dict:
model = {
"graph":
gr.newGraph(directed=True, size=1000, comparefunction=Compare_Keys),
"ldp":
mp.newMap(maptype="PROBING", comparefunction=Compare_Keys),
"cntry":
mp.newMap(maptype="PROBING", comparefunction=Compare_Keys),
"cables":
mp.newMap(maptype="PROBING", comparefunction=Compare_Keys)
}
return model
def graph_mst_prim(self, scan):
graph = gp.newGraph(size=self.mas_grande[1])
distTo = scan['distTo']
edgeTo = scan['edgeTo']
dist_it = ll_it.newIterator(mp.keySet(distTo))
total_dist = 0
while ll_it.hasNext(dist_it):
vertex = ll_it.next(dist_it)
dist = mp.get(distTo, vertex)['value']
if dist:
total_dist += dist
edge = mp.get(edgeTo, vertex)['value']
if not gp.containsVertex(graph, edge['vertexA']):
gp.insertVertex(graph, edge['vertexA'])
if not gp.containsVertex(graph, edge['vertexB']):
gp.insertVertex(graph, edge['vertexB'])
gp.addEdge(graph, edge['vertexA'], edge['vertexB'], dist)
return graph, total_dist
def initialize():
""" Inicializa el analizador:
stops: Tabla de hash para guardar los vertices del grafo.
connections: Grafo para representar las rutas entre estaciones.
components: Almacena la informacion de los componentes conectados.
paths: Estructura que almacena los caminos de costo minimo desde un
vértice determinado a todos los otros vértices del grafo.
"""
try:
analyzer = {
'countries': None,
'connections': None,
'components': None,
'paths': None,
'mst': None,
'dfs': None,
'info_lp': None,
'nombres_lp': None,
'info_cables': None,
'nodos_capitales': None,
"check": None
}
analyzer['countries'] = mp.newMap(numelements=250,
maptype='PROBING',
comparefunction=compareCountry)
analyzer['info_cables'] = mp.newMap(numelements=6000,
maptype='PROBING',
comparefunction=compareCountry)
analyzer['nombres_lp'] = mp.newMap(numelements=4000,
maptype='PROBING',
comparefunction=compareCountry)
analyzer['info_lp'] = mp.newMap(numelements=4000,
maptype='PROBING',
comparefunction=compareCountry)
analyzer['connections'] = gr.newGraph(datastructure='ADJ_LIST',
directed=False,
size=6000,
comparefunction=compareLPids)
analyzer['nodos_capitales'] = lt.newList("ARRAY_LIST")
return analyzer
except Exception as exp:
error.reraise(exp, 'model.newAnalyzer')
def initCatalog():
'''Countries: Mapa de hash que tiene como key el nombre de un pais y valor un diccionario con:
['info']-> informacion del csv del pais
['landing_points']-> landing points en el pais
landing_points: mapa de hash que tiene como key el nombre de la ciudad y valor:
['info']-> informacion del csv del LP
['cables']-> cables en el LP
Connections: grafo en el formato:
vertice: (nombre ciudad)-(nombre cable)
arco: distancia entre 2 ciudades
LP-Name: mapa usado para conseguir nombre de ciudad y pais que corresponden a un ID numerico de un LP
llave-> id del landing point
valor-> tupla (pais, ciudad)
'''
catalog = {
'countries': None,
'landing_points': None,
'connections': None,
'LP-Name': None
}
catalog['countries'] = mp.newMap(numelements=239,
maptype='PROBING',
comparefunction=compareCountries)
catalog['landing_points'] = mp.newMap(
numelements=1280,
maptype='PROBING',
comparefunction=compareLandingPointIds)
catalog['cables'] = mp.newMap(numelements=2000,
maptype='PROBING',
comparefunction=compareCountries)
catalog['connections'] = gr.newGraph(datastructure='ADJ_LIST',
directed=False,
size=3263)
catalog['LP-Name'] = mp.newMap(numelements=1280, maptype='PROBING')
return catalog
def graph():
graph = g.newGraph(size=12, directed=True, comparefunction=compareVertices)
g.insertVertex(graph, 'A1')
g.insertVertex(graph, 'A2')
g.insertVertex(graph, 'A3')
g.insertVertex(graph, 'A4')
g.insertVertex(graph, 'B1')
g.insertVertex(graph, 'B2')
g.insertVertex(graph, 'B3')
g.insertVertex(graph, 'C1')
g.insertVertex(graph, 'C2')
g.insertVertex(graph, 'C3')
g.insertVertex(graph, 'C4')
g.insertVertex(graph, 'C5')
g.addEdge(graph, 'A1', 'A2')
g.addEdge(graph, 'A2', 'A3')
g.addEdge(graph, 'A3', 'A2')
g.addEdge(graph, 'A2', 'A1')
g.addEdge(graph, 'A3', 'A4')
g.addEdge(graph, 'A4', 'A3')
g.addEdge(graph, 'C1', 'C5')
g.addEdge(graph, 'C1', 'C2')
g.addEdge(graph, 'C2', 'C3')
g.addEdge(graph, 'C5', 'C2')
g.addEdge(graph, 'C3', 'C4')
g.addEdge(graph, 'C4', 'C1')
g.addEdge(graph, 'B1', 'B2')
g.addEdge(graph, 'B2', 'B3')
g.addEdge(graph, 'B3', 'B1')
g.addEdge(graph, 'B2', 'B1')
g.addEdge(graph, 'A2', 'C1')
g.addEdge(graph, 'C3', 'A4')
g.addEdge(graph, 'C5', 'B2')
g.addEdge(graph, 'B3', 'C2')
return graph
def crearSubGrafo(catalog, lista_vertices, tamaño):
# Con los vértices del SCC más grande, se crea un subgrafo, obteniendo las
# conexiones del grafo original
catalog_sub = {"connections": None}
catalog_sub["connections"] = gr.newGraph(size=2017)
i = 1
while i < tamaño:
vertice = lt.getElement(lista_vertices, i)
lista_arcos_adyacentes = gr.adjacentEdges(catalog["connections"],
vertice)
for arco in lt.iterator(lista_arcos_adyacentes):
#print(arco)
vertice1 = arco["vertexA"]
vertice2 = arco["vertexB"]
distancia = arco["weight"]
addDistance(catalog_sub, vertice1, vertice2, distancia)
i += 1
subgrafo = catalog_sub["connections"]
return tamaño, subgrafo
def graph3():
graph = g.newGraph(size=8, comparefunction=compareVertices, directed=False)
g.insertVertex(graph, 'Bogota')
g.insertVertex(graph, 'Duitama')
g.insertVertex(graph, 'Armenia')
g.insertVertex(graph, 'Honda')
g.insertVertex(graph, 'Espinal')
g.insertVertex(graph, 'Florencia')
g.insertVertex(graph, 'Cali')
g.insertVertex(graph, 'Medellin')
g.addEdge(graph, 'Bogota', 'Duitama', 5)
g.addEdge(graph, 'Bogota', 'Armenia', 8)
g.addEdge(graph, 'Duitama', 'Armenia', 2)
g.addEdge(graph, 'Armenia', 'Honda', 2)
g.addEdge(graph, 'Espinal', 'Cali', 7)
g.addEdge(graph, 'Cali', 'Medellin', 1)
g.addEdge(graph, 'Espinal', 'Florencia', 2)
g.addEdge(graph, 'Florencia', 'Medellin', 15)
return graph
def newAnalyzer(size, loadfactor):
analyzer = {
'companyByTaxis': None,
'companyByTrips': None,
'datesByTaxis': None,
'graph': None
}
analyzer['companyByTaxis'] = m.newMap(size,
maptype='CHAINING',
loadfactor=loadfactor,
comparefunction=compareTaxis)
analyzer['companyByTrips'] = m.newMap(size,
maptype='CHAINING',
loadfactor=loadfactor,
comparefunction=compareTrips)
analyzer['datesByTaxis'] = om.newMap(omaptype='RBT',
comparefunction=compareDates)
analyzer['graph'] = gr.newGraph(datastructure="ADJ_LIST",
size=size,
comparefunction=compareCommunity)
return analyzer
def graph():
graph = g.newGraph(size=10, comparefunction=compareVertices)
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')
g.addEdge(graph, 'Bogota', 'Medellin')
g.addEdge(graph, 'Bogota', 'Pasto')
g.addEdge(graph, 'Bogota', 'Cali')
g.addEdge(graph, 'Yopal', 'Medellin')
g.addEdge(graph, 'Medellin', 'Pasto')
g.addEdge(graph, 'Cali', 'Pasto')
g.addEdge(graph, 'Cali', 'Barranquilla')
g.addEdge(graph, 'Barranquilla', 'Manizales')
g.addEdge(graph, 'Pasto', 'Manizales')
return graph
import config
from DISClib.ADT import graph as gr
from DISClib.ADT import list as lt
def comparefunction(searchname, element):
if (searchname == element['key']):
return 0
elif (searchname < element['key']):
return -1
return 1
grafo = gr.newGraph(datastructure='ADJ_LIST',
directed=False,
size=14000,
comparefunction=comparefunction)
# Cargar los siguientes datos a un grafo no dirigido:
datos = [{
'id': 1,
'adj': [2, 3]
}, {
'id': 2,
'adj': [1, 3]
}, {
'id': 3,
'adj': [2, 3]
}, {
'id': 4,
def newTargetGraph():
return graph.newGraph('ADJ_LIST', True, 14000, Comparation.compareId)
def digraph():
digraph = g.newGraph(size=10,
directed=True,
comparefunction=compareVertices)
return digraph
def __init__(self):
self.Routes = graph.newGraph("ADJ_LIST", True, 78, cmp.compareId)
def graph():
graph = g.newGraph(size=10, directed=False, comparefunction=comparenames)
return graph
def graph():
graph = g.newGraph(size=10, comparefunction=comparenames)
return graph
