Exemplo n.º 1
0
def newMap(numelements, prime, loadfactor, cmpfunction, ints):
    """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', cmpfunction)
    for _ in range(capacity):
        bucket = lt.newList('SINGLE_LINKED', cmpfunction)
        lt.addLast(table, bucket)
    hashtable = {'prime': prime,
                 'capacity': capacity,
                 'scale': scale,
                 'shift': shift,
                 'table': table,
                 'ints': ints,
                 'size': 0,
                 'comparefunction': cmpfunction,
                 'type': 'CHAINING'}
    return hashtable
Exemplo n.º 2
0
def newHeap(size, 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,
            'offset': 2,
            'cmpfunction': cmpfunction
        }

        heap['elements'] = lt.newList(datastructure='ARRAY_LIST',
                                      cmpfunction=cmpfunction)
        lt.addLast(heap['elements'], None)
        return heap
    except Exception as exp:
        error.reraise(exp, 'newHeap')
def adjacents(graph, vertex):
    """
    Retorna una lista con todos los vertices adyacentes al vertice 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 adyacencias
    Raises:
        Exception
    """
    try:
        element = map.get(graph['vertices'], vertex)
        lst = element['value']
        lstresp = lt.newList()
        iter = it.newIterator(lst)
        while (it.hasNext(iter)):
            edge = it.next(iter)
            v = e.either(edge)
            if (v == vertex):
                lt.addLast(lstresp, e.other(edge, v))
            else:
                lt.addLast(lstresp, v)
        return lstresp
    except Exception as exp:
        error.reraise(exp, 'ajlist:adjacents')
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 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')
Exemplo n.º 6
0
def getEdge(graph, vertexa, vertexb):
    """
    Retorna el arco asociado a los vertices vertexa ---- vertexb

    Args:
        graph: El grafo sobre el que se ejecuta la operacion
        vertexa: Vertice de inicio
        vertexb: Vertice destino

    Returns:
        El arco que une los verices vertexa y vertexb
    Raises:
        Exception
    """
    try:
        element = map.get(graph['vertices'], vertexa)
        lst = element['value']
        itvertex = it.newIterator(lst)
        edges = lt.newList(datastructure='SINGLE_LINKED', cmpfunction=None)
        while (it.hasNext(itvertex)):
            edge = it.next(itvertex)
            if (graph['directed']):
                if (e.either(edge) == vertexa
                        and (e.other(edge, e.either(edge)) == vertexb)):
                    return edge
            elif (e.either(edge) == vertexa
                  or (e.other(edge, e.either(edge)) == vertexb)):
                lt.addLast(edges, edge)
        return edges
    except Exception as exp:
        error.reraise(exp, 'ajlist:getedge')
def edges(graph):
    """
    Retorna una lista con todos los arcos del grafo graph

    Args:
        graph: El grafo sobre el que se ejecuta la operacion

    Returns:
        Una lista con los arcos del grafo
    Raises:
        Exception
    """
    try:
        lstmap = map.valueSet(graph['vertices'])
        itervertex = it.newIterator(lstmap)
        lstresp = lt.newList('SINGLE_LINKED', e.compareedges)
        while it.hasNext(itervertex):
            lstedge = it.next(itervertex)
            iteredge = it.newIterator(lstedge)
            while (it.hasNext(iteredge)):
                edge = it.next(iteredge)
                if (graph['directed']):
                    lt.addLast(lstresp, edge)
                elif (not lt.isPresent(lstresp, edge)):
                    lt.addLast(lstresp, edge)
        return lstresp
    except Exception as exp:
        error.reraise(exp, 'ajlist:edges')
Exemplo n.º 8
0
    def newIndexHeap(cmpfunction):
    """
    Crea un cola de prioridad indexada orientada a menor

    Args:
        cmpfunction: La funcion de comparacion
        size: El numero de elementos
    Returns:
       Una nueva cola de prioridad indexada
    Raises:
        Exception
    """
    try:
        indexheap = {'elements': None,
                     'qpMap': None,
                     'size': 0,
                     'cmpfunction': cmpfunction}
        indexheap['elements'] = lt.newList(datastructure='ARRAY_LIST',
                                           cmpfunction=cmpfunction)
        indexheap['qpMap'] = map.newMap(
                                        maptype='PROBING',
                                        comparefunction=cmpfunction
                                        )
        return indexheap
    except Exception as exp:
        error.reraise(exp, 'indexheap:newindexheap')
def newList(datastructure='SINGLE_LINKED', cmpfunction=None):
    """Crea una lista vacia

    Args:
        cmpfunction: Función de comparación para los elementos de la lista
    Returns:
        Una nueva lista
    Raises:
        Exception
    """
    try:
        lst = lt.newList(datastructure, cmpfunction)
        return lst
    except Exception as exp:
        error.reraise(exp, 'TADList->newList: ')
Exemplo n.º 10
0
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
    """
    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
Exemplo n.º 11
0
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
    """
    ltset = lt.newList('SINGLE_LINKED', map['comparefunction'])
    for pos in range(lt.size(map['table'])):
        bucket = lt.getElement(map['table'], pos + 1)
        for element in range(lt.size(bucket)):
            entry = lt.getElement(bucket, element + 1)
            lt.addLast(ltset, entry['value'])
    return ltset
Exemplo n.º 12
0
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
    """
    bucket = lt.newList()
    empty = True
    for pos in range(lt.size(map['table'])):
        bucket = lt.getElement(map['table'], pos + 1)
        if lt.isEmpty(bucket) is False:
            empty = False
            break
    return empty
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')
Exemplo n.º 14
0
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 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 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")
Exemplo n.º 17
0
def getDateInfo(dateOmap, date):
    """
    Para una fecha devuelve una lista de la cantidad de
    accidentes por severidad y el total de accidentes
    Args:
        dateOmap: Order map organizado por fechas
        date: datetime de la fecha

    Returns:
        Entry con la lista y el total
    """
    dateRoot = om.get(dateOmap, date)
    if dateRoot is None:
        return None
    dateEntry = dateRoot['value']
    severityList = Op.operationSetMap(dateEntry['SeverityIndex'],
                                      Aux.makeListMp, newList('ARRAY_LIST'))
    severityListAndTotal = {
        'list': severityList,
        'total': dateEntry['numAccidents']
    }
    return severityListAndTotal
Exemplo n.º 18
0
def newList(datastructure=None,
            cmpfunction=None,
            key=None,
            filename=None,
            delimiter=","):
    """Crea una lista vacia

    Args:
        datastructure:  Tipo de estructura de datos a utilizar para implementar
        la lista. Los tipos posibles pueden ser: ARRAY_LIST y SINGLE_LINKED.

        cmpfunction: Función de comparación para los elementos de la lista.
        Si no se provee función de comparación se utiliza la función
        por defecto pero se debe proveer un valor para key.
        Si se provee una función de comparación el valor de Key debe ser None.

        Key:  Identificador utilizado para comparar dos elementos de la lista
        con la función de comaparación por defecto.

        filename: Si se provee este valor, se crea una lista a partir
        de los elementos encontrados en el archivo.
        Se espera que sea un archivo CSV UTF8.

        delimiter: Si se pasa un archivo en el parámetro filename, se utiliza
        este valor para separar los campos. El valor por defecto es una coma.

    Returns:
        Una nueva lista
    Raises:
        Exception
    """
    try:
        lst = lt.newList(datastructure, cmpfunction, key, filename, delimiter)
        return lst
    except Exception as exp:
        error.reraise(exp, 'TADList->newList: ')
Exemplo n.º 19
0
def MakeListFormat(Type='ARRAY_LIST'):
    return {'list': newList(Type), 'total': 0}
Exemplo n.º 20
0
    stop=False
    while (rs in range(1, size)) and (ls in range(1,size)) and not stop:
            root=lt.getElement(lst,follower)
            Right_son=lt.getElement(lst, rs)
            Left_son=lt.getElement(lst, ls)
            if cmpfunction(root, Right_son):
                lt.exchange(lst, follower, rs)
                if cmpfunction(Right_son, Left_son):
                    lt.exchange(lst, follower, ls)
                follower=rs
            elif cmpfunction(root, Left_son):
                lt.exchange(lst, follower, ls)
                follower=ls
            else:
                stop=True
            rs=follower*2
            ls=follower*2+1
        
example=hp.newHeap(cmpfunction)
lst=lt.newList()

def cmpfunction(a,b ):
    """
    Compara dos números.
    """
    if a < b:
        return -1
    elif a == b:
        return 0
    else:
        return 1