def rehash(map):
"""
Se aumenta la capacidad de la tabla al doble y se hace rehash de
todos los elementos de la tabla.
"""
try:
newtable = lt.newList('ARRAY_LIST', map['comparefunction'])
capacity = nextPrime(map['capacity'] * 2)
for _ in range(capacity):
entry = me.newMapEntry(None, None)
lt.addLast(newtable, entry)
oldtable = map['table']
map['size'] = 0
map['currentfactor'] = 0
map['table'] = newtable
map['capacity'] = capacity
for pos in range(lt.size(oldtable)):
entry = lt.getElement(oldtable, pos + 1)
if (entry['key'] is not None and entry['key'] != '__EMPTY__'):
hash = hashValue(map, entry['key'])
pos = findSlot(map, entry['key'], hash, map['comparefunction'])
lt.changeInfo(map['table'], abs(pos), entry)
if (pos < 0):
map['size'] += 1
map['currentfactor'] = map['size'] / map['capacity']
return map
except Exception as exp:
error.reraise(exp, 'Probe:rehash')
def put(map, key, value):
""" Ingresa una pareja llave,valor a la tabla de hash.
Si la llave ya existe en la tabla, se reemplaza el valor
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
value: el valor asociado a la pareja
Returns:
El map
Raises:
Exception
"""
try:
hash = hashValue(map, key) # Se obtiene el hascode de la llave
entry = me.newMapEntry(key, value)
pos = findSlot(map, key, hash, map['comparefunction'])
lt.changeInfo(map['table'], abs(pos), entry)
if (pos < 0): # Se reemplaza el valor con el nuevo valor
map['size'] += 1
map['currentfactor'] = map['size'] / map['capacity']
if (map['currentfactor'] >= map['limitfactor']):
rehash(map)
return map
except Exception as exp:
error.reraise(exp, 'Probe:put')
def put(map, key, value):
""" Ingresa una pareja llave,valor a la tabla de hash.
Si la llave ya existe en la tabla, se reemplaza el valor
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
value: el valor asociado a la pareja
Returns:
El map
Raises:
Exception
"""
try:
hash = hashValue(map, key)
bucket = lt.getElement(map['table'], hash)
entry = me.newMapEntry(key, value)
pos = lt.isPresent(bucket, key)
if pos > 0: # La pareja ya exista, se reemplaza el valor
lt.changeInfo(bucket, pos, entry)
else:
lt.addLast(bucket, entry) # La llave no existia
map['size'] += 1
map['currentfactor'] = map['size'] / map['capacity']
if (map['currentfactor'] >= map['limitfactor']):
rehash(map)
return map
except Exception as exp:
error.reraise(exp, 'Chain:put')
def put(map, key, value):
""" Ingresa una pareja llave,valor a la tabla de hash.
Si la llave ya existe en la tabla, se reemplaza el valor
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
value: el valor asociado a la pareja
Returns:
El map
Raises:
Exception
"""
if map['ints']:
hashv = key % map['capacity']
else:
hashv = hashValue(map, key)
bucket = lt.getElement(map['table'], hashv)
entry = me.newMapEntry(key, value)
pos = lt.isPresent(bucket, key)
if pos > 0: # La pareja ya exista, se reemplaza el valor
lt.changeInfo(bucket, pos, entry)
else:
lt.addLast(bucket, entry) # La llave no existia
map['size'] += 1
return map
def rehash(map):
"""
Se aumenta la capacidad de la tabla al doble y se hace rehash de
todos los elementos de la tabla.
"""
try:
newtable = lt.newList("ARRAY_LIST", map["comparefunction"])
capacity = nextPrime(map["capacity"] * 2)
for _ in range(capacity):
entry = me.newMapEntry(None, None)
lt.addLast(newtable, entry)
oldtable = map["table"]
map["size"] = 0
map["currentfactor"] = 0
map["table"] = newtable
map["capacity"] = capacity
for pos in range(lt.size(oldtable)):
entry = lt.getElement(oldtable, pos + 1)
if entry["key"] is not None and entry["key"] != "__EMPTY__":
hash = hashValue(map, entry["key"])
pos = findSlot(map, entry["key"], hash, map["comparefunction"])
lt.changeInfo(map["table"], abs(pos), entry)
if pos < 0:
map["size"] += 1
map["currentfactor"] = map["size"] / map["capacity"]
return map
except Exception as exp:
error.reraise(exp, "Probe:rehash")
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 inicial de la tabla
comparefunction: Funcion de comparación entre llaves
Returns:
Un nuevo map
Raises:
Exception
"""
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,
'comparefunction': comparefunction,
'size': 0,
'type': 'PROBING'}
return hashtable
def newMap(numelements, prime, loadfactor, comparefunction, datastructure):
"""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
datastructure: estructura de datos seleccionada
Returns:
Un nuevo map
Raises:
Exception
"""
try:
capacity = nextPrime(numelements//loadfactor)
scale = rd.randint(1, prime-1)
shift = rd.randint(0, prime-1)
hashtable = {'prime': prime,
'capacity': capacity,
'scale': scale,
'shift': shift,
'table': None,
'currentfactor': 0,
'limitfactor': loadfactor,
'comparefunction': None,
'size': 0,
'type': 'PROBING',
'datastructure': datastructure}
if(comparefunction is None):
cmpfunc = defaultcompare
else:
cmpfunc = comparefunction
hashtable['comparefunction'] = cmpfunc
hashtable['table'] = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=cmpfunc)
for _ in range(capacity):
entry = me.newMapEntry(None, None)
lt.addLast(hashtable['table'], entry)
return hashtable
except Exception as exp:
error.reraise(exp, 'Probe:newMap')
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
"""
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
def put(map, key, value):
""" Ingresa una pareja llave,valor a la tabla de hash.
Si la llave ya existe en la tabla, se reemplaza el valor
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
value: el valor asociado a la pareja
Returns:
El map
Raises:
Exception
"""
hash = hashValue(map, key) # Se obtiene el hascode de la llave
entry = me.newMapEntry(key, value)
pos = findSlot(map, key, hash, map['comparefunction'])
lt.changeInfo(map['table'], abs(pos), entry)
if (pos < 0): # Se reemplaza el valor con el nuevo valor
map['size'] += 1
return map
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 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 newCategory(name, id):
category = me.newMapEntry(name.strip().lower(), id)
return category
def crearParejaCatalogo(key, value):
return me.newMapEntry(key, value)
