def generarSubConjuntosIteracion(estadoPivote, NFA, estados, lenguaje):
for letra in lenguaje:
# mover dado un Estado y una letra
mover = t.mover(NFA, estados[estadoPivote].getEstados(), letra)
if (len(mover) > 0):
# Calcular e_cerradura
e_cerraduraTemp, _ = t.e_cerradura(NFA, mover)
e_cerraduraTemp = list(set(e_cerraduraTemp))
# Se revisa si el estado generado es nuevo o existente
estadoControl, idEstado = isNuevoEstado(estados, e_cerraduraTemp)
if (estadoControl):
# Ya existe un estado igual,
# se crea relacion
estados[estadoPivote].agregarRelacion(
ns.RelacionSubconjuntos(estadoPivote, letra, idEstado))
else:
nuevoEstadoLetraId = nextLetraId()
estados[nuevoEstadoLetraId] = ns.NodoSubconjuntos(
False, e_cerraduraTemp)
estados[estadoPivote].agregarRelacion(
ns.RelacionSubconjuntos(estadoPivote, letra,
nuevoEstadoLetraId))
return estados
def postOrder(self, Node):
'''
Recorre el arbol de forma postoperden
y va construyendo los NFA usando el
algoritmo de Thompson
Parametros
----------
Node: Obj Node
Nodo raiz del arbol
'''
# Si no existe raiz no seguimos
if (Node == None):
return
# Ejecutamos postOrden en los nodos hijos
self.postOrder(Node.getLeft())
self.postOrder(Node.getRight())
if (Node.getValue() in self.operadores):
# Si el nodo actual es un Operadores
if (Node.getValue() == '|'):
NFA1 = self.pila[len(self.pila) - 1]
NFA2 = self.pila[len(self.pila) - 2]
self.pila.pop()
self.pila.pop()
self.pila.append(t.construirOr(NFA1, NFA2))
if (Node.getValue() == '*'):
NFA1 = self.pila[len(self.pila) - 1]
NFA2 = self.pila[len(self.pila) - 2]
self.pila.pop()
self.pila.pop()
self.pila.append(t.construirKleen(NFA2))
if (Node.getValue() == '.'):
NFA1 = self.pila[len(self.pila) - 1]
NFA2 = self.pila[len(self.pila) - 2]
self.pila.pop()
self.pila.pop()
self.pila.append(t.construirConcatenacion(NFA2, NFA1))
else:
# Si el nodo actual no es un operador
self.pila.append(t.construirUnSimbolo(Node.getValue()))
def run():
str_ = e.get()
# graph = Graph()
thom = Thompson(str_)
g = thom.get_nfa()
# nfa显示窗口
nfa_win = tk.Tk("算法构造nfa")
nfa_win.title("算法构造nfa")
# nfa_win.geometry()
t_nfa = tk.Text(nfa_win)
for edge in g.edges:
t_nfa.insert("end", edge.__str__())
# t_nfa.insert("end","testts")
t_nfa.pack()
# nfa_win.mainloop()
dfa_graph, chart = NfaToDfa(g).get_dfa()
# 转移表
tran_win = tk.Tk("转移表")
tran_win.title("转移表")
# nfa_win.geometry()
t_chart = tk.Text(tran_win)
t_chart.insert("end", chart)
# t_nfa.insert("end","testts")
t_chart.pack()
# dfa显示窗口
dfa_win = tk.Tk("nfa转dfa")
dfa_win.title("nfa转dfa")
# nfa_win.geometry()
t_dfa = tk.Text(dfa_win)
for edge in dfa_graph.edges:
t_dfa.insert("end", edge.__str__())
# t_nfa.insert("end","testts")
t_dfa.pack()
print(g)
# draw(g)
draw(dfa_graph)
print(dfa_graph)
def make_dead_state(dfa, input_symbols):
dead_state = DfaState([Thompson.Nfa(None)], 'DEAD')
dead_state.is_accept = False
for symbol in input_symbols:
dead_state.trans[symbol] = dead_state
went_to_dead_state = False
for Dstate in dfa.Dstates:
for symbol in input_symbols:
if not Dstate.trans.get(symbol):
Dstate.trans[symbol] = dead_state
if not went_to_dead_state:
went_to_dead_state = True
if went_to_dead_state:
dfa.Dstates.append(dead_state)
def generarSubConjuntos(NFA):
lenguaje = t.getLenguaje(NFA)
estados = {}
estadosRevisados = [] # los estados que ya se revisaron
idNodoInicial, _ = t.getIdNodoInicio(NFA)
# e-cerradura del estado inicial
e_cerraduraTemp, _ = t.e_cerradura(NFA, [idNodoInicial])
estados[nextLetraId()] = ns.NodoSubconjuntos(True,
list(set(e_cerraduraTemp)))
# Se itera hasta quedarse sin estados por procesar
while (len(colaLetrasId) > 0):
estados = generarSubConjuntosIteracion(getLetraIdActual(), NFA,
estados, lenguaje)
# Se definen los estados finales
idNodoFinal, _ = t.getIdNodoFin(NFA)
estados = ns.setEstadosFinales(estados, idNodoFinal)
return estados
dead_state = DfaState([Thompson.Nfa(None)], 'DEAD')
dead_state.is_accept = False
for symbol in input_symbols:
dead_state.trans[symbol] = dead_state
went_to_dead_state = False
for Dstate in dfa.Dstates:
for symbol in input_symbols:
if not Dstate.trans.get(symbol):
Dstate.trans[symbol] = dead_state
if not went_to_dead_state:
went_to_dead_state = True
if went_to_dead_state:
dfa.Dstates.append(dead_state)
W = Thompson.State('W')
X = Thompson.State('X')
Y = Thompson.State('Y')
Z = Thompson.State('Z')
E = Thompson.State('e')
F = Thompson.State('f')
W.data['trans']['a'] = X
W.data['trans']['b'] = Y
X.data['trans']['E'] = Z
Y.data['trans']['c'] = Z
Z.data['trans']['E'] = W
nfa = Thompson.Nfa('q')
nfa.name = 'hoppa'
nfa.states = [W, X, Y, Z]
import shuntingReg
import Thompson
if __name__ == "__main__":
tests = [["(a.b|b*)", ["ab", "b", "bb", "a"]],
["a.(b.b)*.a", ["aa", "abba", "aba"]]]
a_list = []
myfile = open("graphTextFile.txt", "r")
for element in myfile:
oneLine = element.strip()
full_line = oneLine.split()
a_list.append(full_line)
myfile.close()
for test in tests:
infix = test[0]
print(f"infix: {infix}")
postfix = shuntingReg.shunt(infix)
print(f"postfix: {postfix}")
nfa = Thompson.re_to_nfa(postfix)
print(f"Thompson: {nfa}")
for s in test[1]:
match = nfa.match(s)
print(f"Match '{s}': {match}")
print()
# graph.add_edge(edge)
# # 初始节点连接结束节点
# new_node = graph.get_new_state()
# edge = Edge(new_node, save_state, "初始节点连接结束节点")
# graph.add_edge(edge)
# # 初始连接连接内部开始节点
# edge = Edge(new_node, inner_begin, "初始连接连接内部开始节点")
# graph.add_edge(edge)
# else:
# edge = link(scaner)
# graph.add_edge(edge)
#
# return begin
if __name__ == '__main__':
str = input("请输入正规式：\n")
# graph = Graph()
thom = Thompson(str)
g = thom.get_nfa()
print(g)
print(g.start_state)
draw()
dfa_graph = NfaToDfa(g).get_dfa()
print(dfa_graph)
# if stack.front() != '|' != '(' != ')':
# graph.get_new_state()
# scan(0)
# print(graph)
Alg = Semibandits.EpsGreedy(S,
learning_alg=learning_alg,
classification=False)
if Args.param is not None:
start = time.time()
(r, reg, val_tmp) = Alg.play(Args.T,
verbose=True,
params={
'eps': Args.param,
'train_all': True,
'schedule': 'lin'
})
stop = time.time()
if Args.alg == 'thompson':
import Thompson
Alg = Thompson.Thompson(S)
if Args.param is not None:
start = time.time()
(r, reg, val_tmp) = Alg.play(Args.T,
verbose=True,
params={'lambda': Args.param})
stop = time.time()
if Args.alg == 'bag':
import LangevinCB, NNModels
Alg = LangevinCB.BagCB(S) # , model=NNModels.TwoLayer)
if Args.param is not None:
start = time.time()
(r, reg, val_tmp) = Alg.play(Args.T,
verbose=True,
params={'lr': Args.param},
loss=Args.loss)
return estados
def simularNFD(NFD, cadena):
s = ns.getEstadosIniciales(NFD)[0]
for i in cadena:
if (s == []):
break
s = ns.mover(NFD[s], i)
# Si la interseccion de S y los estados finales no es vacia
# Entonces se acepta la cadena
if (list(set.intersection(set(s), set(ns.getEstadosFinales(NFD)))) != []):
return "SI"
else:
return "NO"
if __name__ == '__main__':
NFA1 = t.construirUnSimbolo("a")
NFAKleen = t.construirKleen(NFA1)
NFA2 = t.construirUnSimbolo("b")
NFAOR = t.construirOr(NFAKleen, NFA2)
generarSubConjuntos(NFAOR)
#g.visualizarNFA(NFAOR)
if temp != -1:
temp2 = posicion(nodos,transiciones[i][2])
if temp2 != -1:
nodos[temp].agregar_transicion(transiciones[i][1],temp2)
i = 0
for i in range(0,len(nodos)):
temp = completar(simbolos,simbolos_transitivos(nodos[i],simbolos))
j = 0
for j in range(0,len(temp)):
nodos[i].agregar_transicion(temp[j],estados.index(-1))
imprimir_tabla(nodos,simbolos)
Nuevos_estados = []
estados_alcanzables = [str(estados[inicial[0]])]
estados_alcanzables += Thompson.Cerradura_E(transiciones,str(estados[inicial[0]]))
Nuevos_estados.append(Thompson.Estado_AFD('A',estados_alcanzables,0))
bandera = 1
while bandera != 0:
bandera = 0
i = 0
for i in range(0,len(Nuevos_estados)):
j = 0
for j in range(0,len(simbolos)):
estados_alcanzables = Thompson.Ir_a(transiciones,simbolos[j],Nuevos_estados[i])
if Thompson.analisis(Nuevos_estados,estados_alcanzables):
letra = chr(ord(Nuevos_estados[len(Nuevos_estados) - 1].simbolo) + 1)
if Thompson.final(final,estados_alcanzables,estados):
Nuevos_estados.append(Thompson.Estado_AFD(letra,estados_alcanzables,2))
else: