def addtomap(citibike, trip):
fecha = trip["starttime"]
fecha = transformador_fecha(fecha, 1)
existe = om.get(citibike["mapa_fecha"], fecha)
if existe is None:
mapa = structure_map()
llave = trip["bikeid"]
ruta = gr.newGraph(
datastructure="ADJ_LIST",
directed=True,
size=50,
comparefunction=compareStations,
)
addTripV2(ruta, trip)
m.put(mapa, llave, ruta)
om.put(citibike["mapa_fecha"], fecha, mapa)
else:
llave = trip["bikeid"]
existe = me.getValue(existe)
existev2 = m.get(existe, llave)
if existev2 is None:
ruta = gr.newGraph(
datastructure="ADJ_LIST",
directed=True,
size=50,
comparefunction=compareStations,
)
addTripV2(ruta, trip)
m.put(existe, llave, ruta)
else:
grafo = me.getValue(existev2)
addTripV2(grafo, trip)
def newcatalog():
catalog = {
'countries': None,
'connections': None,
'points': None,
'points2': None,
'compo': None,
'rutas': None,
'mst': None
}
catalog['points'] = mp.newMap(numelements=4000,
maptype='PROBING',
comparefunction=compareVerIds)
catalog['connections'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=20000,
comparefunction=compareVerIds)
catalog['mst'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=20000,
comparefunction=compareVerIds)
catalog['countries'] = lt.newList(datastructure='ARRAY_LIST')
catalog['points2'] = lt.newList(datastructure='ARRAY_LIST')
return catalog
def newAnalyzer():
try:
analyzer = {
'countries': None,
"landing_points": None,
'connections_distance': None,
'connections_capacity': None,
'components': None,
'id_dado_lp': None,
'paths': None,
"identificadores": None
}
analyzer['countries'] = mp.newMap(loadfactor=0.5, maptype='PROBING')
analyzer["country_dado_city"] = mp.newMap(loadfactor=0.5,
maptype='PROBING')
analyzer['landing_points_country'] = mp.newMap(loadfactor=0.5,
maptype='PROBING')
analyzer["id_dado_lp"] = mp.newMap(loadfactor=0.5, maptype='PROBING')
analyzer["location_dado_id"] = mp.newMap(loadfactor=0.5,
maptype='PROBING')
analyzer["name_dado_id"] = mp.newMap(loadfactor=0.5, maptype='PROBING')
analyzer["landing_points"] = mp.newMap(loadfactor=0.5,
maptype='PROBING')
analyzer["cables_dado_lpid"] = mp.newMap(loadfactor=0.5,
maptype='PROBING')
analyzer['vertices'] = mp.newMap(loadfactor=0.5, maptype='PROBING')
analyzer['vertices_aux'] = mp.newMap(loadfactor=0.5, maptype='PROBING')
analyzer["edges"] = mp.newMap(loadfactor=0.5, maptype='PROBING')
analyzer['connections_distance'] = gr.newGraph(
datastructure='ADJ_LIST',
directed=True,
size=5000,
comparefunction=None)
analyzer['connections_capacity'] = gr.newGraph(
datastructure='ADJ_LIST',
directed=True,
size=5000,
comparefunction=None)
return analyzer
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def newAnalyzerC():
""" 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 almancena los caminos de costo minimo desde un
vertice determinado a todos los otros vértices del grafo
"""
try:
analyzer = {
'graph': None,
'stops': None,
'components': None,
'connections': None,
'paths': None,
'agesOrigen': None,
'agesDestino': None,
'latitud': None,
'longitud': None
}
analyzer["graph"]= gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=compareStopIds)
analyzer['stops'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareStopIds)
analyzer["connections"]= gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=compareStopIds)
analyzer['agesOrigen'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareAges)
analyzer['agesDestino'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareAges)
analyzer['latitud'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareAges)
analyzer['longitud'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareAges)
return analyzer
except Exception as exp:
error.reraise(exp, 'model:newAnalyzerC')
def newAnalyzer():
""" 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 almancena los caminos de costo minimo desde un
vertice determinado a todos los otros vértices del grafo
"""
citibike = {
'graph': None,
"llegadas": None,
"id": None,
"req5": None,
"Nombre": None
}
citibike['graph'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=300,
comparefunction=compareStopIds)
citibike['Age'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=300,
comparefunction=compareStopIds)
citibike['Day'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=300,
comparefunction=compareStopIds)
citibike["Nombre"] = m.newMap(numelements=300,
maptype="PROBING",
loadfactor=0.4,
comparefunction=comparellegada)
citibike["llegadas"] = m.newMap(numelements=300,
maptype="PROBING",
loadfactor=0.4,
comparefunction=comparellegada)
citibike["id"] = m.newMap(numelements=300,
maptype="PROBING",
loadfactor=0.4,
comparefunction=comparellegada)
citibike["req5"] = m.newMap(numelements=300,
maptype="PROBING",
loadfactor=0.4,
comparefunction=comparellegada)
citibike["coordenadas"] = m.newMap(numelements=300,
maptype="PROBING",
loadfactor=0.4,
comparefunction=comparellegada)
return citibike
def newAnalyzer():
""" Inicializa el analizador
points: Tabla de hash para guardar los vertices del grafo
connections: Grafo para representar los cables entre landing points
components: Almacena la informacion de los componentes conectados
countries: Tabla de hash para guardar información de los países y sus capitales
paths: Estructura que almancena los caminos de costo minimo desde un
vertice determinado a todos los otros vértices del grafo
relatedVertex: Tabla de hash que toma como llave el codigo de un landing point y
guarda una lista con todos los vertices asociados
"""
try:
analyzer = {
'points': None,
'connections': None,
'components': None,
'countries': None,
'paths': None,
'relatedVertex': None,
'componentsGraph': None,
'cables': None,
'IPs': None
}
analyzer['points'] = m.newMap(numelements=1400,
maptype='PROBING',
comparefunction=compareStopIds)
analyzer['connections'] = gr.newGraph(datastructure='ADJ_LIST',
directed=False,
size=14000,
comparefunction=compareStopIds)
analyzer['countries'] = m.newMap(numelements=300,
maptype='PROBING',
comparefunction=compareCountries)
analyzer['relatedVertex'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareStopIds)
analyzer['componentsGraph'] = gr.newGraph(
datastructure='ADJ_LIST',
directed=False,
size=14000,
comparefunction=compareStopIds)
analyzer['cables'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareCountries)
return analyzer
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def newAnalyzer():
try:
citibike = {
'graph': None,
'lsttrips': None,
'divide': None,
'grafo': None,
'StationI': None,
'StationF': None
}
citibike['graph'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=compareStations)
citibike['lsttrips'] = lt.newList('SINGLE_LINKED', compareStations)
citibike['divide'] = {}
citibike['grafo'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=compareStations)
citibike['StationI'] = mp.newMap(numelements=300317,
prime=109345121,
maptype='CHAINING',
loadfactor=1.0,
comparefunction=comparer)
citibike['StationF'] = mp.newMap(numelements=300317,
prime=109345121,
maptype='CHAINING',
loadfactor=1.0,
comparefunction=comparer)
citibike['namesI'] = mp.newMap(numelements=300317,
prime=109345121,
maptype='CHAINING',
loadfactor=1.0,
comparefunction=comparer)
citibike['namesF'] = mp.newMap(numelements=300317,
prime=109345121,
maptype='CHAINING',
loadfactor=1.0,
comparefunction=comparer)
citibike['suscripcion'] = mp.newMap(numelements=300317,
prime=109345121,
maptype='CHAINING',
loadfactor=1.0,
comparefunction=comparer)
return citibike
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def inicio():
datos = {
'pais': None,
'landing': None,
'pais_cable': None,
'capacidad': None,
'cables': None,
}
datos['pais'] = mp.newMap(numelements=14000,
maptype='PROBING',
comparefunction=comparemap)
datos['pais_cable'] = mp.newMap(numelements=14000,
maptype='PROBING',
comparefunction=comparemap)
datos['capacidad'] = mp.newMap(numelements=14000,
maptype='PROBING',
comparefunction=comparemap)
datos['landing'] = mp.newMap(numelements=1400,
maptype='PROBING',
comparefunction=comparemap)
datos['cables'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=14000,
comparefunction=comparegrafo)
return datos
def newAnalyzer():
try:
analyzer = {
'trips': None,
'connections': None,
'EstacionesXid': None,
'components': None,
'years': None,
'coordinates': None
}
analyzer['trips'] = m.newMap(numelements=14000,
maptype='CHAINING',
comparefunction=compareStations)
analyzer['EstacionesXid'] = m.newMap(numelements=14000,
maptype='CHAINING',
comparefunction=compareBikeid)
analyzer['connections'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=14000,
comparefunction=compareStations)
analyzer['years'] = m.newMap(numelements=14000,
maptype='CHAINING',
comparefunction=compareDates)
analyzer['coordinates'] = m.newMap(numelements=1000,
comparefunction=compareStations)
return analyzer
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def newAnalyzer():
try:
analyzer = {
'cables': None,
"landingPoints": None,
'connections': None,
'components': None,
'paths': None
}
analyzer['cables'] = mp.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareLandingPointIds)
analyzer["landingPoints"] = mp.newMap(
numelements=14000,
maptype='PROBING',
comparefunction=compareLandingPointIds)
analyzer['connections'] = gr.newGraph(
datastructure='ADJ_LIST',
directed=False,
size=14000,
comparefunction=compareLandingPointIds)
return analyzer
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def newAnalyzer():
try:
citibike = {
'graph': None,
'stations': None,
'exitStations': None,
'arriveStations': None,
'totalStations': None,
'paths': None
}
citibike['graph'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=compareStations)
citibike['exitStations'] = m.newMap(1019,
maptype='PROBING',
loadfactor=0.5,
comparefunction=compareStations)
citibike['arriveStations'] = m.newMap(1019,
maptype='PROBING',
loadfactor=0.5,
comparefunction=compareStations)
citibike['totalStations'] = m.newMap(1019,
maptype='PROBING',
loadfactor=0.5,
comparefunction=compareStations)
citibike['stations'] = lt.newList('ARRAY_LIST', compareStations)
return citibike
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def newAnalyzer():
citibike = {"graph": None, "components": None}
citibike["graph"] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=compareStations)
return citibike
def minSpanTree(graph):
search = prim.PrimMST(graph)
vertices = gr.vertices(graph)
mst = gr.newGraph(datastructure='ADJ_LIST',
directed=False,
size=14000,
comparefunction=compareStopIds)
for vert in lt.iterator(vertices):
gr.insertVertex(mst, vert)
keys = m.keySet(search['edgeTo'])
totalWeight = 0
for key in lt.iterator(keys):
edge = m.get(search['edgeTo'], key)
gr.addEdge(mst, edge['value']['vertexA'], edge['value']['vertexB'],
edge['value']['weight'])
totalWeight += edge['value']['weight']
longest = longestPath(mst)
sizeMst = (gr.numVertices(mst))
results = (sizeMst, totalWeight, longest)
return results
def newCatalog():
catalog = {'landing_points': None, 'countries': None, 'grafo': None}
#llaves son landing_point__id, valores son toda la info del lp
catalog['landing_points'] = mp.newMap(maptype='PROBING',
loadfactor=0.5,
comparefunction=CompareLandingPoints)
#llaves son nombres de lp, valores son los landing_point_id para acceder al mapa de arriba
catalog['landing_points2'] = mp.newMap(
maptype='PROBING',
loadfactor=0.5,
comparefunction=CompareLandingPoints)
#llaves son ['cable_name'] valores son toda la info del cable del archivo de conexiones
catalog['cables'] = mp.newMap(loadfactor=4.0)
#llaves son nombres de paises, valores son toda la info del pais
catalog['countries'] = mp.newMap(loadfactor=4.0)
#llaves son nombres de capitales, valores son los nombres de paises para acceder al mapa de arriba
catalog['countries2'] = mp.newMap(loadfactor=4.0)
#grafo : vertices: lp-cables y capitales, arcos:conexiones por cable y conexiones terrestres con capitales (y
# conexiones triviales entre vertices del mismo lp)
catalog['grafo'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
comparefunction=CompareLandingPoints,
size=2800)
#aqui se guardara la info general que retorna el algoritmmo de Kosaraju sobre el grafo
catalog['Kosaraju'] = None
catalog['MST'] = None
return catalog
def newAnalyzer():
""" Inicializa el analizador
landing_points: 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 almancena los caminos de costo minimo desde un
vertice determinado a todos los otros vértices del grafo
"""
try:
analyzer = {
'landingPoints': None,
'countries': None,
'connections': None,
}
analyzer['landingPoints'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareIds)
analyzer['countries'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareIds)
analyzer['connections'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=14000,
comparefunction=compareIds)
analyzer['connectionsLst'] = lt.newList()
return analyzer
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def NewMacrostructure():
macrostructure = {
"connections": None,
"countries": None,
"lp": None,
"cables": None
}
macrostructure['connections'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=3262,
comparefunction=compareLPs)
macrostructure['countries'] = mp.newMap(numelements=238,
maptype='PROBING',
comparefunction=None)
macrostructure['lp'] = mp.newMap(numelements=1279,
maptype='PROBING',
comparefunction=None)
macrostructure['lp-names'] = mp.newMap(numelements=1279,
maptype='PROBING',
comparefunction=None)
macrostructure['cables'] = mp.newMap(numelements=1279,
maptype='PROBING',
comparefunction=compareLPs)
return macrostructure
def newCitibike():
citibike = {
'stations': None,
'connections': None,
'idName_stations': None,
'components': None,
'coords': None
}
citibike['stations'] = m.newMap(numelements=1000,
maptype='PROBING',
comparefunction=compareStations)
citibike['name_IDstations'] = m.newMap(numelements=1000,
comparefunction=compareStations)
citibike['connections'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=compareStations)
citibike['coords'] = m.newMap(numelements=1000,
comparefunction=compareStations)
citibike['components'] = om.newMap(omaptype='BST',
comparefunction=compareroutes)
return citibike
def grafo_nuevo():
citybike = {"grafo": None}
citybike["grafo"] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=comparar_data)
return citybike
def newAnalyzer():
""" 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 almancena los caminos de costo minimo desde un
vertice determinado a todos los otros vértices del grafo
"""
try:
analyzer = {
'landing_points': None,
'connections': None,
'components': None,
'paths': None,
'countries': None,
'MST': None,
'cables': None
}
#informacion de los cables de cada landing point, los valores son listas de cables
analyzer['landing_points_cables'] = m.newMap(numelements=1280,
maptype='PROBING')
#diccionarios con informacion de cada landing point, los valores son diccionarios con caracteristicas
analyzer['landing_points_info'] = m.newMap(numelements=1280,
maptype='PROBING')
analyzer['connections'] = gr.newGraph(datastructure='ADJ_LIST',
directed=False,
size=1280,
comparefunction=compare_vertices)
analyzer['countries'] = m.newMap(numelements=1280, maptype='PROBING')
analyzer['cables_band'] = m.newMap()
return analyzer
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def newAnalyzer():
""" 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 almancena los caminos de costo minimo desde un
vertice determinado a todos los otros vértices del grafo
"""
try:
citibike = {
'stops': None,
'graph': None,
'components': None,
'idscc': None
}
citibike['idscc'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareStopIds)
citibike['stops'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareStopIds)
citibike['graph'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=compareStopIds)
return citibike
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def newAnalyzer():
analyzer = {
'countries': None,
'landing_points': None,
'countries_cables': None,
'capacity': None,
'cables': None,
}
"""
Se carga en una tabla de Hash el archivo de countries
Llave: Nombre
Valor: Diccionario con su información
"""
analyzer['countries'] = mp.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareValue)
"""
Se almacena en una tabla de Hash todos los cables que llegan a los paises
Llave: Nombre Pais
Valor: Lista de diccionarios de las conecciones
{"nombre conexion", "capacidad", "nombre vertice"}
"""
analyzer['countries_cables'] = mp.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareValue)
"""
Se almacena la capacidad de cada conexion en una tabla de Hash
Llave: Nombre conexion (origen-destino-cable)
Valor: Capacidad
"""
analyzer['capacity'] = mp.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareValue)
"""
Se carga en una table de Hash el archivo de landing-points
Llave: Id landing point(numero)
Valor: Diccionario con la información
"""
analyzer['landing_points'] = mp.newMap(numelements=1400,
maptype='PROBING',
comparefunction=compareValue)
"""
Se carga en una table de Hash las conexiones de un landing point
Llave: Nombre landing point
Valor: Lista de vertices
"""
analyzer['landing_points_cables'] = mp.newMap(numelements=1400,
maptype='PROBING',
comparefunction=compareValue)
"""
Se carga en un grafo las conecciones entre landing points
Vertices: <Nombre Landing Point>-<Nombre cable>
"""
analyzer['cables'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=14000,
comparefunction=compareLPs)
return analyzer
def newAnalyzer():
""" Inicializa el analizador
Crea una lista vacia para guardar todos los crimenes
Se crean indices (Maps) por los siguientes criterios:
-Fechas
Retorna el analizador inicializado.
"""
clasificacion = "fechas"
analyzer = {
'accidentes': None,
clasificacion: None,
'connections': None,
'duracion': None,
'rango': None,
'promedios': None
}
analyzer['accidentes'] = lt.newList('SINGLE_LINKED', compareIds)
analyzer[clasificacion] = om.newMap(omaptype='RBT',
comparefunction=compareDates)
analyzer['connections'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1400,
comparefunction=compareStopIds)
analyzer["rango"] = {}
analyzer["duracion"] = {}
analyzer["promedios"] = {}
return analyzer
def newAnalyzer():
try:
citibike = {
'graph': None,
'stops': None,
'pairs': None
#'components': None,
#'paths': None
}
citibike['stops'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareStations)
citibike['graph'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=compareStations)
citibike['pairs'] = m.newMap(numelements=14000,
maptype='PROBING',
comparefunction=comparePairs)
citibike['dates'] = om.newMap(omaptype='RBT',
comparefunction=compareDates)
return citibike
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def newAnalyzer():
""" Inicializa el analizador
stations: Tabla de hash para guardar los vertices del grafo
graph: Grafo para representar las rutas entre estaciones
components: Almacena la informacion de los componentes conectados
paths: Estructura que almancena los caminos de costo minimo desde un
vertice determinado a todos los otros vértices del grafo
"""
analyzer = {'stationsStart': None,
'stationsEnd': None,
'graph': None,
'bikes':None,
'components': None,
'paths': None
}
analyzer['stationsEnd'] = m.newMap(numelements=2000,
maptype='PROBING',
comparefunction=compareStations)
analyzer['stationsStart'] = m.newMap(numelements=2000,
maptype='PROBING',
comparefunction=compareStations)
analyzer['bikes'] = m.newMap(numelements=2000,
maptype='PROBING',
comparefunction=compareBikes)
analyzer['graph'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=10000,
comparefunction=compareStations)
return analyzer
def newAnalyzer():
try:
analyzer = {
'Vertices': None,
'Arcos': None,
'components': None,
'paths': None,
'landing_points': None,
'paises_nombre': None,
'paises_codigos': None
}
analyzer['Vertices'] = mp.newMap(numelements=14000,
maptype='PROBING',
comparefunction=compareStopIds)
analyzer['Arcos'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=14000,
comparefunction=compareStopIds)
analyzer["landing_points"] = mp.newMap(
) # llave: nombre_ciudad / valor: linea
analyzer["paises_nombre"] = mp.newMap(
) # llave: nombre_pais / valor: landing_point_id
analyzer["paises_codigos"] = mp.newMap(
) # llave: landing_point_id / valor: linea
analyzer["countries"] = mp.newMap() # llave CountryName / valor: linea
analyzer["cables_origen"] = mp.newMap(
) # llave: Num. de llegada / valor: linea
analyzer["ciudad_pais"] = mp.newMap() # llave: name / valor: linea
return analyzer
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def newCatalog():
try:
catalog = {
'totalCabs': None,
'companies': None,
'services': None,
'graph': None, # <-------------- Aquí se crea el grafo
'paths': None,
'dates': None
}
catalog['totalCabs'] = m.newMap(20143,
maptype='PROBING',
loadfactor=0.5,
comparefunction=compareCabsById)
catalog['companies'] = m.newMap(4447,
maptype='PROBING',
loadfactor=0.5,
comparefunction=compareCompaniesByName)
catalog['services'] = lt.newList('ARRAY_LIST')
catalog['graph'] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=compareStations)
catalog['dates'] = om.newMap(omaptype='RBT',
comparefunction=compareDates)
return catalog
except Exception as exp:
error.reraise(exp, 'model:newCatalog')
def initCatalog():
"""
landinpoints: mapa - key: solo el landinpoint con el id, value: info -> toda la info del landinpoints.csv, lstcables -> lista de todos los cabels que llegan a ese landpoint
internet_graph: grafo (tipo de vertides: <lp>-<cables>, <capitalCity>-locales, arcos: peso - distancia harvesine)
components: almacena info de componentes conectados
paths: Estructura que almancena los caminos de costo minimo desde un ertice determinado a todos los otros vértices del grafo
countries: mapa Key: Pais, Value: toda la info para cada pais de countries.csv, la
cables: mapa, Key: cable_name, Value: info -> info de los cables (lenght, capacityTBS...), lstlandingpoints -> landinpoints que conecta ese cable
"""
catalog = {
"landing_points": None,
"internet_graph": None,
"components": None,
"paths": None,
"countries": None,
"cables": None,
'lp_names': None
}
catalog['landingpoints'] = mp.newMap(numelements=14000, maptype='PROBING')
catalog['lp_names'] = mp.newMap(numelements=14000, maptype='PROBING')
catalog["cables"] = mp.newMap(numelements=14000, maptype='PROBING')
catalog["countries"] = mp.newMap(numelements=14000, maptype='PROBING')
catalog["capitals"] = mp.newMap(numelements=14000, maptype='PROBING')
catalog['internet_graph'] = gr.newGraph(datastructure='ADJ_LIST',
directed=False,
size=14000,
comparefunction=cmpLandingPoints)
return catalog
def initcatalogo():
catalogo = {
'vertices': None,
'conexiones': None,
"paises": None,
"listavertices": None,
"mapaises": None,
"invertices": None,
"capitales": None
}
catalogo["vertices"] = m.newMap(numelements=14000, maptype='PROBING')
catalogo['conexiones'] = gr.newGraph(datastructure='ADJ_LIST',
directed=False,
size=14000,
comparefunction=None)
catalogo["paises"] = m.newMap(numelements=14000, maptype='PROBING')
catalogo["invertices"] = m.newMap(numelements=14000, maptype='PROBING')
catalogo["mapaises"] = m.newMap(numelements=500, maptype='PROBING')
catalogo["listavertices"] = lt.newList("ARRAY_LIST")
catalogo["capitales"] = m.newMap(numelements=500, maptype='PROBING')
return catalogo
def create_Hash(Taxis):
for i in Taxis["lst"]:
timeHash = datetime.datetime.strptime(i, "%H:%M")
EachGraph = gr.newGraph(datastructure="ADJ_LIST",
directed=True,
size=100,
comparefunction=compareStopIds)
m.put(Taxis["Hash"], timeHash.time(), EachGraph)
def analyzer():
analyzer = {"Grafo por ID":None,
"Grafo por CA":None,
"indice":None,
"tripList":None}
analyzer["indice"] = m.newMap(numelements=1000,
maptype="PROBING",
loadfactor=0.5,
comparefunction=comparerMap)
analyzer["Grafo por ID"] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=comparer)
analyzer["Grafo por CA"] = gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=comparer)
analyzer["tripList"] = lt.newList(datastructure="SINGLE_LINKED")
return analyzer
