コード例 #1
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
    """
    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")
コード例 #2
0
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: ')
コード例 #3
0
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')
コード例 #4
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")
コード例 #5
0
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')
コード例 #6
0
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')
コード例 #7
0
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')
コード例 #8
0
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')
コード例 #9
0
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')
コード例 #10
0
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: ')
コード例 #11
0
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: ')
コード例 #12
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("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')
コード例 #13
0
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')
コード例 #14
0
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')
コード例 #15
0
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')
コード例 #16
0
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')
コード例 #17
0
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')
コード例 #18
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
    """
    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')
コード例 #19
0
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')
コード例 #20
0
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')
コード例 #21
0
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: ')
コード例 #22
0
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: ')
コード例 #23
0
ファイル: list.py プロジェクト: Javier6804/Proyecto-EDA
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: ')
コード例 #24
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
    """
    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')
コード例 #25
0
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')
コード例 #26
0
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')
コード例 #27
0
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')
コード例 #29
0
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')
コード例 #30
0
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')