Python Node.addTransition方法代码示例

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import addTransition [as 别名]
    def noAceptarVacia(self):
        # Verificamos que el AFD acepta una palabra vacia
        if self.validateSecuence(""):
            # Transiciones que tenemos que agregar al nuevo nodo inicial
            transitions = self.nodes[self.getFirst()].getTransitions()

            # Buscamos un nombre valido para el nuevo nodo
            nodesCounter = 0
            newNodeName = "Q" + str(nodesCounter)

            while self.nodes.has_key(newNodeName):
                nodesCounter += 1
                newNodeName = "Q" + str(nodesCounter)

            # Seteamos el nuevo nodo como final y agregamos la transicion al inicial actual
            node = Node(newNodeName, True)
            for symbol, transitionsToAdd in transitions.iteritems():
                for destination in transitionsToAdd:
                    node.addTransition(symbol, destination)

            # Reiniciamos el listado de nodos (No podemos agregar una entrada al inicio en un orderecDict)
            newNodes = collections.OrderedDict()

            # Agregamos el nodo al AF usando el nombre del nodo como llave
            newNodes[node.getName()] = node
            self.first = node.getName()

            # Agregamos el resto de los elementos al nuevo listado de nodos
            for nodeName, node in self.nodes.iteritems():
                newNodes[nodeName] = node

            # Reemplazamos el listado de nodos
            self.nodes = newNodes

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import addTransition [as 别名]
    def kleene(self):
        first = self.getFirst()

        # Buscamos un nombre valido para el nuevo nodo
        nodesCounter = 0
        newNodeName = "Q" + str(nodesCounter)

        while self.nodes.has_key(newNodeName):
            nodesCounter += 1
            newNodeName = "Q" + str(nodesCounter)

        # Seteamos el nuevo nodo como final y agregamos la transicion al inicial actual
        node = Node(newNodeName, True)
        node.addTransition("E", first)

        # Reiniciamos el listado de nodos (No podemos agregar una entrada al inicio en un orderecDict)
        newNodes = collections.OrderedDict()

        # Agregamos el nodo al AF usando el nombre del nodo como llave
        newNodes[node.getName()] = node
        self.first = node.getName()

        # Agregamos el resto de los elementos al nuevo listado de nodos
        for nodeName, node in self.nodes.iteritems():
            newNodes[nodeName] = node

            # Si es final agregamos la transicion vacia al nodo inicial
            if node.isFinal():
                node.addTransition("E", first)

        # Reemplazamos el listado de nodos
        self.nodes = newNodes

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import addTransition [as 别名]
    def _loadFromFile(self, af, filename):
        if not os.path.isfile(filename):
            print "El archivo indicado no existe."
            sys.exit()

        f = open(filename)

        # Leemos el archivo linea a linea
        for line in f:
            # Removemos el salto de linea final
            line = line.rstrip()

            # Dividimos la linea usando un espacio como separacion
            data = line.split()

            # Verificamos que tenga mas de 1 parametro
            # (Se requiere por lo menos el nombew y si es final o no)
            if len(data) > 1:
                # Usamos la primera palabra como nombre del nodo
                nodeName = data[0]

                # Usamos la segunda palabra para verificar si es un nodo final o no
                # Si es "S", es final, en otro caso no lo es
                final = True if data[1] == "S" else False

                # Creamos el nodo con esos 2 parametros y los borramos de la lista
                # Para luego iterar sobre las transiciones
                node = Node(nodeName, final)

                del data[:1]

                # Analizamos transicion a transicion
                for transition in data:
                    # Separamos la palabra usando ":", si la lista resultante tiene 2 entradas
                    # (Simbolo y estado al que avanza)
                    transition = transition.split(":")
                    if len(transition) == 2:
                        # Si es valido se agrega la transicion al nodo
                        node.addTransition(transition[0], transition[1])

                # Se agrega el nodo al AF
                af.addNode(node)

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import addTransition [as 别名]
    def union(self, af):
        currentNodes = copy.copy(self.getNodes().keys())
        extraNodes = af.getNodes()

        nodesCounter = 1

        renames = {}

        # Renombramos los nodos del nuevo AF que existen en el primero
        for nodeName, node in extraNodes.iteritems():
            if nodeName in currentNodes:
                newNodeName = "Q" + str(nodesCounter)

                while newNodeName in currentNodes:
                    nodesCounter += 1
                    newNodeName = "Q" + str(nodesCounter)

                renames[nodeName] = newNodeName
                node.setName(newNodeName)
                nodesCounter += 1

        for oldNodeName, newNodeName in renames.iteritems():
            for nodeName, node in extraNodes.iteritems():
                node.replaceTransition(newNodeName, oldNodeName)

        firstNodeAF = af.getFirst()

        if renames.has_key(firstNodeAF):
            firstNodeAF = renames[firstNodeAF]

        # Buscamos un nombre valido para el nuevo nodo
        newNodeName = "Q" + str(nodesCounter)

        while self.nodes.has_key(newNodeName) or renames.has_key(newNodeName):
            nodesCounter += 1
            newNodeName = "Q" + str(nodesCounter)

        # Seteamos el nuevo nodo como no-final y agregamos la transicion al inicial de cada AF
        node = Node(newNodeName, False)
        node.addTransition("E", self.getFirst())
        node.addTransition("E", firstNodeAF)

        # Reiniciamos el listado de nodos (No podemos agregar una entrada al inicio en un orderecDict)
        newNodes = collections.OrderedDict()

        # Agregamos el nodo al AF usando el nombre del nodo como llave
        newNodes[node.getName()] = node
        self.first = node.getName()

        # Agregamos los elementos del AF actual al nuevo listado de nodos
        for nodeName, node in self.nodes.iteritems():
            newNodes[nodeName] = node

        # Agregamos los elementos del nodo que se une al nuevo listado de nodos
        for nodeName, node in af.nodes.iteritems():
            # Tenemos que reescribir la variable, cuando cambiamos el nombre no cambiamos
            # el indice en el listado de nodos
            nodeName = node.getName()
            newNodes[nodeName] = node

        # Reemplazamos el listado de nodos
        self.nodes = newNodes

        # Actualizamos el listado de simbolos validos
        self.updateSymbols()

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import addTransition [as 别名]
    def toAFD(self):
        # Si el AF ya es un AFD devolvemos la instancia
        if self.isAFD():
            return self

        # Iniciamos un contador para los nodos que usaremos para eliminar
        # las secuencias con longitud mayor que 1
        tempNodeID = 1

        # Iteramos sobre los nodos
        for nodeName, node in self.nodes.iteritems():
            # Obtenemos las transiciones de cada nodo
            for symbol, transition in node.getTransitions().iteritems():
                # Revisamos si a secuencia tiene longitud mayor que 1
                if len(symbol) > 1:
                    # Invertimos la secuencia
                    reverseSymbol = symbol[::-1]

                    # Cada nodo que vayamos creando apuntara al ultimo creado
                    # en el primer caso es a la transicion completa del simbolo
                    lastNode = transition

                    # Seteamos una variable con el nombre del ultmo nodo temporal creado
                    # para usarlo en la transicion del nodo inicial
                    tempNodeName = None

                    # Leemos la secuencia invertida caracter a caracter, excepto por el ultimo
                    # (o sea, el primero de la secuencia) ya que ese lo usaremos en el nodo inicial
                    for i in range(0, (len(reverseSymbol) - 1)):
                        # Obtenemos el caracter de la secuencia
                        singleSymbol = reverseSymbol[i]

                        # Creamos un nodo temporal de nombre "tempID", donde ID lo obtenemos 
                        # de un contador incremental. El nodo no es final.
                        tempNodeName = "temp%s" % (tempNodeID)
                        tempNode = Node(tempNodeName, False)

                        # Si es la primera iteracion haremos la transicion desde el nodo
                        # a todos los que apuntaba la secuencia inicial, si es un una iteracion mayor
                        # apuntaremos el nodo al ultimo nodo temporal creado
                        for nextNode in lastNode:
                            tempNode.addTransition(singleSymbol, nextNode)

                        # Agregamos el nodo al AF
                        self.addNode(tempNode)

                        # Seteamos la variable lastNode con el nodo recien creado para la siguiente iteracion
                        lastNode = [tempNodeName]

                        #Aumentamos el contador del nodo intermedio
                        tempNodeID += 1

                    # Luego de desarmar la secuencia eliminamos la transicion del nodo original
                    # y creamos una transicion al ultimo nodo temporal creado
                    node.removeTransition(symbol)
                    node.addTransition(symbol[0], tempNodeName)

        # Actualizamos el listado de simbolos validos
        self.symbols = []
        self.updateSymbols()

        # Instanciamos un nuevo AF para el AFD
        newAF = AF()
        # Creamos un contados para los nombres de los nodos
        nodesCounter = 0
        # Creamos diccionarios para asociar grupos de nodos con su nombre y vice-versa
        nodeNameByTransitions = {}  # Get nodeName using the group of nodes
        transitionsByNodeName = {}  # Get group of Nodes using the nodeName
        # Creamos un directorio de nodos
        nodes = {}
        # Creamos una lista con los nuevos nodos que crearemos, como solo agregaremos
        # nodos no hay problemas en modificarlo mientras iteramos
        nodesToIterate = []

        # Asumimos que el primer nodo del AFD es el nodo inicial (Premisa)
        firstNode = self.nodes.itervalues().next()

        # Obtenemos la clausura del nodo inicial
        transitions = self._getClausura([firstNode.getName()])
        # Creamos un string con los nodos obtenidos en la clausura, porque las llaves de los
        # diccionarios no pueden ser mutables
        transitionString = '|'.join(str(v) for v in transitions)

        # Seteamos el nombre del nodo inicial
        nodeName = "Q" + str(nodesCounter)
        # Asociamos el nombre del nuevo nodo con los nodos primitivos que lo componen
        nodeNameByTransitions[transitionString] = nodeName
        transitionsByNodeName[nodeName] = transitions
        # Agregamos el nodo al listado de nodos por iterar
        nodesToIterate.append(nodeName)
        # Determinamos si el nuevo nodo sera final
        isFinal = self._newNodeIsFinal(transitions)

        # Creamos un nuevo nodo y lo agregamos al AFD
        node = Node(nodeName, isFinal)
        newAF.addNode(node)

        # Agregamos el nodo al listado de nodos usango el nombre como llave
        nodes[nodeName] = node

#.........这里部分代码省略.........