def valueSet(map):
"""
Retorna una lista con todos los valores de la tabla de hash
Args:
map: El map
Returns:
lista de valores
Raises:
Exception
"""
try:
ltset = lt.newList("ARRAY_LIST")
for pos in range(lt.size(map["table"])):
entry = lt.getElement(map["table"], pos + 1)
if entry["value"] is not None and entry["value"] != "__EMPTY__":
lt.addLast(ltset, entry["value"])
return ltset
except Exception as exp:
error.reraise(exp, "Probe:valueset")
def insertElement(lst, element, pos):
""" Inserta el elemento element en la posición pos de la lista.
Inserta el elemento en la posición pos de la lista.
La lista puede ser vacía.
Se incrementa en 1 el tamaño de la lista.
Args:
lst: La lista en la que se va a insertar el elemento
element: El elemento a insertar
pos: posición en la que se va a insertar el elemento,
0 < pos <= size(lst)
Raises:
Exception
"""
try:
lt.insertElement(lst, element, pos)
except Exception as exp:
error.reraise(exp, 'TADList->insertElement: ')
def PrimMST(graph):
"""
Implementa el algoritmo de Prim
Args:
graph: El grafo de busqueda
Returns:
La estructura search con los MST
Raises:
Exception
"""
try:
search = initSearch(graph)
vertices = g.vertices(graph)
for vert in lt.iterator(vertices):
if not map.get(search['marked'], vert)['value']:
prim(graph, search, vert)
return search
except Exception as exp:
error.reraise(exp, 'prim:PrimMST')
def keySet(map):
"""
Retorna una lista con todas las llaves de la tabla de hash
Args:
map: El map
Returns:
lista de llaves
Raises:
Exception
"""
try:
ltset = lt.newList()
for pos in range(lt.size(map["table"])):
entry = lt.getElement(map["table"], pos + 1)
if entry["key"] is not None and entry["key"] != "__EMPTY__":
lt.addLast(ltset, entry["key"])
return ltset
except Exception as exp:
error.reraise(exp, "Probe:keyset")
def get(map, key):
""" Retorna la pareja llave, valor, cuya llave sea igual a key
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
Returns:
Una pareja <llave,valor>
Raises:
Exception
"""
try:
hash = hashValue(map, key)
pos = findSlot(map, key, hash, map['comparefunction'])
if pos > 0:
element = lt.getElement(map['table'], pos)
return element
else:
return None
except Exception as exp:
error.reraise(exp, 'Probe:get')
def remove(map, key):
""" Elimina la pareja llave,valor, donde llave == key.
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
Returns:
El map
Raises:
Exception
"""
try:
hash = hashValue(map, key)
pos = findSlot(map, key, hash, map['comparefunction'])
if pos > 0:
entry = me.newMapEntry('__EMPTY__', '__EMPTY__')
lt.changeInfo(map['table'], pos, entry)
map['size'] -= 1
return map
except Exception as exp:
error.reraise(exp, 'Probe:remove')
def contains(map, key):
""" Retorna True si la llave key se encuentra en el map
o False en caso contrario.
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
Returns:
True / False
Raises:
Exception
"""
try:
hash = hashValue(map, key)
pos = findSlot(map, key, hash, map['comparefunction'])
if (pos > 0):
return True
else:
return False
except Exception as exp:
error.reraise(exp, 'Probe:contains')
def newAnalyzer():
try:
taxis = {
'theServices': None,
'grafos': None
}
taxis['theServices']=m.newMap(numelements=1000,
maptype='PROBING',
comparefunction=compareCompanies)
taxis['grafos']=gr.newGraph(datastructure='ADJ_LIST',
directed=True,
size=1000,
comparefunction=compareCompanies)
return taxis
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def addPointConne(catalog, coneccion):
try:
idorigen = coneccion['origin']
idedestino = coneccion['destination']
cable = coneccion['cable_id']
origen = formatVertex(idorigen, cable)
destino = formatVertex(idedestino, cable)
if 'n.a.' in coneccion['cable_length']:
distancia = 1000
else:
distancia = float(coneccion['cable_length'].replace(',','').strip(' km'))
addVer(catalog, origen)
addVer(catalog, destino)
addConne(catalog, origen, destino, distancia)
addConne(catalog, destino, origen, distancia)
addPointcable(catalog, idorigen, cable)
addPointcable(catalog, idedestino, cable)
return catalog
except Exception as exp:
error.reraise(exp, 'model:addPointConne')
def isPresent(lst, element):
""" Informa si el elemento element esta presente en la lista.
Informa si un elemento está en la lista.
Si esta presente, retorna la posición en la que se encuentra
o cero (0) si no esta presente. Se utiliza la función de comparación
utilizada durante la creación de la lista para comparar los elementos.
Args:
lst: La lista a examinar
element: El elemento a buscar
Returns:
Raises:
Exception
"""
try:
return lt.isPresent(lst, element)
except Exception as exp:
error.reraise(exp, 'TADList->isPresent: ')
def deleteElement(lst, pos):
""" Elimina el elemento en la posición pos de la lista.
Elimina el elemento que se encuentra en la posición pos de la lista.
Pos debe ser mayor que cero y menor o igual al tamaño de la lista.
Se decrementa en un uno el tamñao de la lista.
La lista no puede estar vacia.
Args:
lst: La lista a retoranr
pos: Posición del elemento a eliminar.
Raises:
Exception
"""
try:
lst['elements'].pop(pos - 1)
lst['size'] -= 1
except Exception as exp:
error.reraise(exp, 'arraylist->deleteElement: ')
def keySet(map):
"""
Retorna una lista con todas las llaves de la tabla de hash
Args:
map: El map
Returns:
lista de llaves
Raises:
Exception
"""
try:
ltset = lt.newList("ARRAY_LIST")
for pos in range(lt.size(map['table'])):
entry = lt.getElement(map['table'], pos + 1)
if (entry['key'] is not None and entry['key'] != '__EMPTY__'):
lt.addLast(ltset, entry['key'])
return ltset
except Exception as exp:
error.reraise(exp, 'Probe:keyset')
def indegree(graph, vertex):
"""
Retorna el numero de arcos que llegan al vertice vertex
Args:
graph: El grafo sobre el que se ejecuta la operacion
vertex: El vertice del que se desea conocer el grado
Returns:
El grado del vertice
Raises:
Exception
"""
try:
if (graph['directed']):
degree = map.get(graph['indegree'], vertex)
return degree['value']
return 0
except Exception as exp:
error.reraise(exp, 'ajlist:indegree')
def insertVertex(graph, vertex):
"""
Inserta el vertice vertex en el grafo graph
Args:
graph: El grafo sobre el que se ejecuta la operacion
vertex: El vertice que se desea insertar
Returns:
El grafo graph con el nuevo vertice
Raises:
Exception
"""
try:
edges = lt.newList()
map.put(graph['vertices'], vertex, edges)
if (graph['directed']):
map.put(graph['indegree'], vertex, 0)
return graph
except Exception as exp:
error.reraise(exp, 'ajlist:insertvertex')
def insert(heap, element):
"""
Guarda la pareja llave-valor en el heap. Lo guarda en la última
posición y luego hace swim del elemento
Args:
heap: El arreglo con la informacion
element: El elemento a guardar
Returns:
El heap con el nuevo elemento
Raises:
Exception
"""
try:
heap['size'] += 1
lt.insertElement(heap['elements'], element, heap['size'])
swim(heap, heap['size'])
return heap
except Exception as exp:
error.reraise(exp, 'heap:insert')
def minKeyNode(root):
"""
Retorna la menor llave de la tabla de simbolos
Args:
root: La raiz del arbol de busqueda
Returns:
El elemento mas izquierdo del arbol
Raises:
Exception
"""
try:
min = None
if (root is not None):
if (root['left'] is None):
min = root
else:
min = minKeyNode(root['left'])
return min
except Exception as exp:
error.reraise(exp, 'BST:minKeyNode')
def maxKeyNode(root):
"""
Retorna la mayor llave de la tabla de simbolos
Args:
bst: La tabla de simbolos
Returns:
El elemento mas derecho del árbol
Raises:
Exception
"""
try:
max = None
if (root is not None):
if (root['right'] is None):
max = root
else:
max = maxKeyNode(root['right'])
return max
except Exception as exp:
error.reraise(exp, 'BST:maxKeyNode')
def isEmpty(map):
""" Informa si la tabla de hash se encuentra vacia
Args:
map: El map
Returns:
True: El map esta vacio
False: El map no esta vacio
Raises:
Exception
"""
try:
empty = True
for pos in range(lt.size(map['table'])):
entry = lt.getElement(map['table'], pos + 1)
if (entry['key'] is not None and entry['key'] != '__EMPTY__'):
empty = False
break
return empty
except Exception as exp:
error.reraise(exp, 'Probe:isEmpty')
def newHeap(cmpfunction):
"""
Crea un nuevo heap basado en un arreglo, cuyo primer elemento
es inicializado en None y no será utilizado
Args:
cmpfunction: La funcion de comparacion
size: El numero de elementos
Returns:
El heap
Raises:
Exception
"""
try:
heap = {'elements': None, 'size': 0, 'cmpfunction': cmpfunction}
heap['elements'] = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=cmpfunction)
return heap
except Exception as exp:
error.reraise(exp, 'newHeap')
def distTo(search, vertex):
"""
Retorna el costo para llegar del vertice
source al vertice 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:
visited_v = map.get(search['visited'], vertex)
if visited_v is None:
return math.inf
return visited_v['value']['distTo']
except Exception as exp:
error.reraise(exp, 'dks:disto')
def changeInfo(lst, pos, element):
""" Cambia la informacion contenida en el nodo de la lista que se
encuentra en la posicion pos.
Args:
lst: La lista a examinar
pos: la posición de la lista con la información a cambiar
newinfo:
La nueva información que se debe poner en el nodo de la posición pos
Raises:
Exception
"""
try:
if (lst['type'] == 'ARRAY_LIST'):
alt.changeInfo(lst, pos, element)
else:
slt.changeInfo(lst, pos, element)
except Exception as exp:
error.reraise(exp, 'List->changeInfo: ')
def removeFirst(lst):
""" Remueve el primer elemento de la lista.
Elimina y retorna el primer elemento de la lista.
El tamaño de la lista se decrementa en uno.
Si la lista es vacía se retorna None.
Args:
lst: La lista a examinar
Raises:
Exception
"""
try:
if (lst['type'] == 'ARRAY_LIST'):
return alt.removeFirst(lst)
else:
return slt.removeFirst(lst)
except Exception as exp:
error.reraise(exp, 'List->removeFirst: ')
def addFirst(lst, element):
"""Agrega un elemento a la lista en la primera posicion.
Agrega un elemento en la primera posición de la lista, se incrementa
el tamaño de la lista en uno.
Args:
lst: La lista don de inserta el elemento
element: El elemento a insertar en la lista
Returns:
La lista con el nuevo elemento en la primera posición, si el proceso fue exitoso
Raises:
Exception
"""
try:
lt.addFirst(lst, element)
except Exception as exp:
error.reraise(exp, 'TADList->addFirst: ')
def valueSet(map):
"""
Retorna una lista con todos los valores de la tabla de hash
Args:
map: El map
Returns:
lista de valores
Raises:
Exception
"""
try:
ltset = lt.newList()
for pos in range(lt.size(map['table'])):
entry = lt.getElement(map['table'], pos + 1)
if (entry['value'] is not None and entry['value'] != '__EMPTY__'):
lt.addLast(ltset, entry['value'])
return ltset
except Exception as exp:
error.reraise(exp, 'Probe:valueset')
def adjacentEdges(graph, vertex):
"""
Retorna una lista con todos los arcos asociados a los vértices
adyacentes de vertex
Args:
graph: El grafo sobre el que se ejecuta la operacion
vertex: El vertice del que se quiere la lista
Returns:
La lista de arcos adyacentes
Raises:
Exception
"""
try:
element = map.get(graph['vertices'], vertex)
lst = element['value']
return lst
except Exception as exp:
error.reraise(exp, 'ajlist:adjacentEdges')
def keys(rbt, keylo, keyhi):
"""
Retorna todas las llaves del arbol que se encuentren entre
[keylo, keyhi]
Args:
bst: La tabla de simbolos
keylo: limite inferior
keylohi: limite superiorr
Returns:
Las llaves en el rago especificado
Raises:
Exception
"""
try:
lstkeys = lt.newList('SINGLELINKED', rbt['cmpfunction'])
lstkeys = keysRange(rbt['root'], keylo, keyhi, lstkeys,
rbt['cmpfunction'])
return lstkeys
except Exception as exp:
error.reraise(exp, 'RBT:keys')
def newAnalyzer():
try:
analyzer = {
'LandingPointI': None,
'LandingPointN': None,
'connectionsDistance': None,
'connectionsCapacity': None,
'countrysInfo': None,
'components': None,
}
analyzer['LandingPointI'] = mp.newMap(
numelements=1290,
maptype='PROBING',
comparefunction=compareCountryNames)
analyzer['LandingPointN'] = mp.newMap(
numelements=1290,
maptype='PROBING',
comparefunction=compareCountryNames)
analyzer['connectionsDistance'] = gr.newGraph(
datastructure='ADJ_LIST',
directed=True,
size=3500,
comparefunction=compareLanCableIds)
analyzer['connectionsCapacity'] = gr.newGraph(
datastructure='ADJ_LIST',
directed=True,
size=3500,
comparefunction=compareLanCableIds)
analyzer['countriesInfo'] = mp.newMap(
numelements=240,
maptype='PROBING',
comparefunction=compareCountryNames)
return analyzer
except Exception as exp:
error.reraise(exp, 'model:newAnalyzer')
def initSearch(graph, source):
"""
Inicializa la estructura de busqueda y deja
todos los arcos en infinito.
Se inserta en la cola indexada el vertice source
Args:
graph: El grafo a examinar
source: El vertice fuente
Returns:
Estructura de busqueda inicializada
Raises:
Exception
"""
try:
search = {'source': source, 'visited': None, 'iminpq': None}
search['visited'] = map.newMap(
numelements=g.numVertex(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
vertices = g.vertices(graph)
itvertices = it.newIterator(vertices)
while (it.hasNext(itvertices)):
vert = it.next(itvertices)
map.put(search['visited'], vert, {
'marked': False,
'edgeTo': None,
'distTo': math.inf
})
map.put(search['visited'], source, {
'marked': True,
'edgeTo': None,
'distTo': 0
})
pq = iminpq.newIndexMinPQ(cmpfunction=graph['comparefunction'])
search['iminpq'] = pq
iminpq.insert(search['iminpq'], source, 0)
return search
except Exception as exp:
error.reraise(exp, 'dks:init')
def newMap(numelements, prime, loadfactor, comparefunction):
"""Crea una tabla de simbolos (map) sin orden
Crea una tabla de hash con capacidad igual a nuelements
(primo mas cercano al doble de numelements).
prime es un número primo utilizado para el cálculo de los codigos
de hash, si no es provisto se utiliza el primo 109345121.
Args:
numelements: Tamaño inicial de la tabla
prime: Número primo utilizado en la función MAD
loadfactor: Factor de carga maximo de la tabla
comparefunction: Funcion de comparación entre llaves
Returns:
Un nuevo map
Raises:
Exception
"""
try:
capacity = nextPrime(numelements // loadfactor)
scale = rd.randint(1, prime - 1) + 1
shift = rd.randint(1, prime)
table = lt.newList('ARRAY_LIST', comparefunction)
for _ in range(capacity):
entry = me.newMapEntry(None, None)
lt.addLast(table, entry)
hashtable = {
'prime': prime,
'capacity': capacity,
'scale': scale,
'shift': shift,
'table': table,
'currentfactor': 0,
'limitfactor': loadfactor,
'comparefunction': comparefunction,
'size': 0,
'type': 'PROBING'
}
return hashtable
except Exception as exp:
error.reraise(exp, 'Probe:newMap')
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')