def transform(param_1):
states, initial, final, transitions = prog.fileParser(param_1)
print("Novo automato pos operacao de Conversao: ")
if not prog.afn_checker(transitions):
util.infoAutomata(states, initial, final, transitions)
else:
prog.automataConverter(states, initial, final, transitions)
def union(param_1, param_2):
# Coletando informações sobre os dois automatos.
states_1, initial_1, final_1, transitions_1 = prog.fileParser(param_1, 1)
states_2, initial_2, final_2, transitions_2 = prog.fileParser(param_2, 2)
# novo estado para unir os automatos.
new_state = 'q0'
# As seguintes operacoes sao para o novo automato gerado pela UNIAO
# estados
states_u = [new_state] + states_1 + states_2
# estado inicial
initial_u = new_state
# Estados finais
final_u = final_1 + final_2
# transicao do estado novo para os antigos estados iniciais
transition_initial = {new_state: {'e': [initial_1, initial_2]}}
# Concatenando as transicoes dos automatos
# Esta forma de concatenar dicionarios eh mais eficiente
transitions_u = dict(transition_initial, **transitions_1)
# Unindo as transicoes
transitions_u.update(transitions_2)
print("Novo automato gerado pela Uniao:")
util.infoAutomata(states_u, initial_u, final_u, transitions_u)
def intersection(param_1, param_2):
# Automato 1
states_1, initial_1, final_1, transitions_1 = prog.fileParser(param_1, 1)
# Automato 2
states_2, initial_2, final_2, transitions_2 = prog.fileParser(param_2, 2)
# A união dos automatos resulta na uniao de seus estados
new_states = states_1 + states_2
# O estado inicial do resultado da uniao eh o estado inicial do primeiro
new_initial = initial_1
# O estado de aceitacao do resultado da uniao eh o estado final do segunda
new_final = final_2
# As transicoes do novo automato gerado pela uniao eh constituida das transicoes de ambos,
# com algumas alteracoes
transitions_1.update(transitions_2)
# Para esta operacao, eh adicionada uma transicao epslon partido do estado
# de aceitacao do primeiro automato para o estado inicial do segundo automato,
# este fato decorre de que por ser uma interseccao, ambos os automatos devem
# aceitar a palavra inserida, logo, ambos os estados de aceitacao deverao ser
# alcancados, um apos o outro.
for qF in final_1:
if not qF in transitions_1:
transitions_1[qF] = {}
if not "e" in transitions_1[qF]:
transitions_1[qF]['e'] = []
transitions_1[qF]['e'].append(initial_2)
print("Novo automato pos operacao de Interseccao: ")
util.infoAutomata(new_states, new_initial, new_final, transitions_1)
def star(param_1):
states, initial, final, transitions = prog.fileParser(param_1)
new_state = 'q0'
states_e = [new_state] + states
initial_e = new_state
final_e = [new_state] + final
transitions_e = util.operationTransition(new_state, initial, transitions,
final)
print("Novo automato pos operacao estrela: ")
util.infoAutomata(states_e, initial_e, final_e, transitions_e)
def complemento(param_1):
states, initial, final, transitions = prog.fileParser(param_1)
if prog.afn_checker(transitions):
states, initial, final, transitions = prog.automataConverter(
states, initial, final, transitions, False)
# print(states, initial, final, transitions)
states_c = states
initial_c = initial
final_c = util.myFilter(states, final)
transitions_c = transitions
print("O complemento do automato é: ")
util.infoAutomata(states_c, initial_c, final_c, transitions_c, True)
def simulator(param_1, param_2):
word = param_2
states, initial, final, transitions = prog.fileParser(param_1)
util.infoAutomata(states, initial, final, transitions)
print(prog.wordParser(states, initial, final, transitions, word))
def automataConverter(states, initial, final, transitions, output_req=True):
# Power set dos estados
states_power_set = util.states_power_set(states)
transitions["Ø"] = {"0": "Ø", "1": "Ø"}
# Para cada estado no power set de estados
for ps_state in states_power_set:
# Se este estado nao tiver nenhuma transicao no automato,
# esta sera criada
if (len(ps_state) > 1 and not (ps_state in transitions)
and ps_state) or (len(ps_state) == 1 and
(ps_state[0] not in transitions)):
# Criar um novo slot na estutura de transicoes para um estado unico
if len(ps_state) == 1:
transitions[ps_state[0]] = {}
# Cria um novo slot na estrutura de transicoes para estados complexos
else:
transitions[ps_state] = {}
# Para cada sub-estado (A) no estado composto (A, B)
for state in ps_state:
# Para cada simbolo que gere uma transicao neste estado
for symbol in transitions[state]:
# Cria um slot para a transicao do novo estado com os simbolos que nao estao presentes neste
if not symbol in transitions[ps_state]:
transitions[ps_state][symbol] = []
# Realizamos a uniao das transocoes dos sub-estados geradores do estado
transitions[ps_state][symbol] += transitions[state][symbol]
# Setando os estados de aceitacao do AFD como todos que possuem em sua composicao
# ao menos um dos estados de aceitacao da AFN original
for transition in transitions:
if set(transition) & set(final):
final.append(util.beatifyState(transition))
# Define os estados do automato como todos os alcancaveis, limpando assim a saida do programa
afd_states = get_reachable_states(initial, transitions)
# Adiciona o estado lixo aos estados do AFD
afd_states.add(("Ø", ))
# Define as transicoes do afd como todas as que sao possiveis de serem percorridas.
afd_transitions = clear_states(transitions,
get_reachable_states(initial, transitions))
# Define o estado inicial do afd, como todos os estados alcançaveis por transicoes epslon,
# o chamado eplson closure
afd_initial = util.get_epslon_closure(initial, transitions)
# Formatando os estados textualmente, para que fique na forma {a,b} ou a
for st in afd_states.copy():
if len(st) == 1:
afd_states.remove(st)
afd_states.add("".join(map(str, st)))
else:
afd_states.remove(st)
afd_states.add(util.beatifyState(st))
# Retira todos os estados finais inalcancaveis
afd_final = [st for st in final if st in afd_states]
afd_transitions = afn_to_afd_transitions(afd_transitions)
if output_req:
util.infoAutomata(afd_states, afd_initial, afd_final, afd_transitions,
True)
return (afd_states, afd_initial, afd_final, afd_transitions)