def faire_la_concatenation(automate1: Automate, automate2: Automate):
initial = automate1.etat_initial
final = list(automate2.etats_finaux)[-1]
for etat in automate1.etats_finaux:
automate2.remplacer_etat(automate2.etat_initial, etat)
nouveaux_etats = [*automate1.etats, *automate2.etats]
nouvelle_transition = [*automate1.transitions, *automate2.transitions]
nouvel_alphabet = Alphabet([*automate1.alphabet.list, *automate2.alphabet.list])
automate = Automate(nouvel_alphabet, nouveaux_etats, initial, [final], nouvelle_transition)
return automate
def regex(self):
text = self.lineReconnaisance.text()
if (text):
nom, ok = QtWidgets.QInputDialog.getText(self.window,
'Nouvel Automate',
'Entrez le nom')
if ok:
result = ExpressionReguliere(text).convertir_en_afn()
result.definir_nom(nom or text)
self.list[nom or text] = Automate.a_partir_de(result)
self.automate.copie_automate(Automate.a_partir_de(result))
def newDialog(self):
text, ok = QtWidgets.QInputDialog.getText(self.window,
'Nouvel Automate',
'Entrez le nom')
if ok:
a = Automate(Alphabet([]), [], None, [], [])
a.definir_nom(text)
try:
self.liste_automate[text] = a
except:
self.liste_automate[text + '(1)'] = a
self.creation.ui.createBtn.setState()
self.automate.copie_automate(a)
def a_partir_du_symbole(symbole):
if not isinstance(symbole, str):
raise TypeError('Un symbole dois etre de type str')
alphabet = Alphabet([symbole])
initial = GenerateurAutomate.etat_initial()
final = GenerateurAutomate.etat_final()
transition = Transition(initial,symbole,final)
return Automate(alphabet,[initial,final],initial,[final],[transition])
def showUnionDialog(self):
if not self.liste_automate or len(self.liste_automate) < 2:
return
item, ok = QtWidgets.QInputDialog.getItem(
self.window, f"Faire l'union de {self.automate.nom} avec",
"Liste des automates", self.liste_automate, 0, False)
if ok and item:
print(f"item {item}")
print(type(self.liste_automate[item]))
resultat = self.automate.union_automate(
Automate.a_partir_de(self.liste_automate[item]))
resultat.definir_nom(self.automate.nom + ' U ' +
self.liste_automate[item].nom)
print(
f'parents {resultat.parents} Nom {[a.nom for a in resultat.parents]}'
)
self.liste_automate[resultat.nom] = Automate.a_partir_de(resultat)
self.automate.copie_automate(Automate.a_partir_de(resultat))
self.creation.ui.createBtn.setState()
def faire_union(automate1: Automate, automate2: Automate):
if not isinstance(automate1, Automate) or not isinstance(
automate2, Automate):
raise TypeError("L'addition se fais uniquement entre les automate")
initial = GenerateurAutomate.etat_initial()
final = GenerateurAutomate.etat_final()
ancien_initial = [automate1.etat_initial, automate2.etat_initial]
ancien_finaux = [*automate1.etats_finaux, *automate2.etats_finaux]
nouveaux_etats = [*automate1.etats, *automate2.etats, initial, final]
nouvelle_transition = [*automate1.transitions, *automate2.transitions]
nouvel_alphabet = Alphabet(
[*automate1.alphabet.list, *automate2.alphabet.list])
automate = Automate(nouvel_alphabet, nouveaux_etats, initial, [final],
nouvelle_transition)
for etat in ancien_initial:
transition_initial = Transition(initial, '', etat)
automate.ajoute_transition(transition_initial)
for etat in ancien_finaux:
transition_final = Transition(etat, '', final)
automate.ajoute_transition(transition_final)
return automate
nouvel_alphabet = Alphabet(
[*automate1.alphabet.list, *automate2.alphabet.list])
automate = Automate(nouvel_alphabet, nouveaux_etats, initial, [final],
nouvelle_transition)
return automate
@staticmethod
def etat():
GenerateurAutomate.compteur_etat += 1
return Etat(f'Q{GenerateurAutomate.compteur_etat}')
@staticmethod
def etat_initial():
GenerateurAutomate.compteur_etat_initial += 1
return Etat(f'I{GenerateurAutomate.compteur_etat_initial}')
@staticmethod
def etat_final():
GenerateurAutomate.compteur_etat_final += 1
return Etat(f'F{GenerateurAutomate.compteur_etat_final}')
if __name__ == '__main__':
a = Automate(Alphabet(['1']), [Etat('a'), Etat('b')], Etat('a'),
[Etat('b')], [Transition(Etat('a'), '1', Etat('b'))])
b = Automate(Alphabet(['2']), [Etat('c'), Etat('d')], Etat('c'),
[Etat('d')], [Transition(Etat('c'), '2', Etat('d'))])
a.visualiser()
b.visualiser()
GenerateurAutomate.faire_kleen(a).visualiser()
self.liste_automate[text] = a
except:
self.liste_automate[text + '(1)'] = a
self.creation.ui.createBtn.setState()
self.automate.copie_automate(a)
alphabet = Alphabet(['1', '2', '3'])
a = Etat('a')
b = Etat('b')
c = Etat('c')
t1 = Transition(a, '1', b)
t2 = Transition(a, '1', a)
t3 = Transition(a, '2', b)
t4 = Transition(b, '1', b)
automata = Automate(alphabet, [a, b, c], a, [a, c], [t1, t2, t3, t4])
automata.definir_nom('Brains')
def run_app(automate=automata):
import sys
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow(automata)
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
if __name__ == "__main__":
def convertir_en_afn(self):
parenthese = False
expression_entre__parenthese = str()
symbole_vers_automate = dict()
expression_traite = list()
index_suivant = 0;
longeur_expression = len(self.expression)
sauter_le_prochain_symbole = False
faire_loperation_sur_la_dernier_expression = False
for symbole in self.expression:
print(symbole)
index_suivant += 1
print(f"index suivant {index_suivant} total {longeur_expression}")
if symbole == ')':
if parenthese:
parenthese = False
automate_correspondant = ExpressionReguliere(expression_entre__parenthese).convertir_en_afn()
symbole_vers_automate[f'P{index_suivant - 1}'] = automate_correspondant
expression_traite.append(f'P{index_suivant - 1}')
faire_loperation_sur_la_dernier_expression = True
expression_entre__parenthese=str()
else:
raise ValueError(f'Parenthese fermante pas approprie au symbole {index_suivant}')
if parenthese:
expression_entre__parenthese += symbole
elif symbole == '(':
parenthese = True
continue
#TODO FAIRE CE CAS
pass
else:
if symbole in ['*', '|', '.', '+']:
if index_suivant == 1:
raise ValueError('Une Expression ne peux pas commencer par un operateur')
else:
if symbole == '.':
expression_traite.append('.')
elif symbole in ['|', '+']:
expression_traite.append('+')
continue
if sauter_le_prochain_symbole:
sauter_le_prochain_symbole = False
continue
if index_suivant <= longeur_expression:
try:
symbole_suivant = self.expression[index_suivant]
except:
symbole_suivant = None
operation_de_concatenation = True
operation_de_addition = False
operation_de_kleen = False
if symbole_suivant == '*':
operation_de_kleen = True
elif symbole_suivant in ['|','+']:
operation_de_addition = True
if operation_de_kleen:
if faire_loperation_sur_la_dernier_expression:
automate_correspondant = GenerateurAutomate.faire_kleen(symbole_vers_automate[expression_traite[-1]])
symbole_vers_automate[expression_traite[-1]] = automate_correspondant
faire_loperation_sur_la_dernier_expression = False
else:
automate_correspondant = GenerateurAutomate.a_partir_du_symbole(symbole)
automate_correspondant = GenerateurAutomate.faire_kleen(automate_correspondant)
symbole_vers_automate[f'{symbole}{index_suivant-1}'] = automate_correspondant
expression_traite.append(f'{symbole}{index_suivant-1}')
expression_traite.append('.')
print('Kleen a fait')
print(expression_traite)
elif operation_de_addition:
if faire_loperation_sur_la_dernier_expression:
expression_traite.append('+')
faire_loperation_sur_la_dernier_expression = False
continue
automate_correspondant = GenerateurAutomate.a_partir_du_symbole(symbole)
symbole_vers_automate[f'{symbole}{index_suivant - 1}'] = automate_correspondant
#automate_correspondant.visualiser()
expression_traite.append(f'{symbole}{index_suivant - 1}')
expression_traite.append('+')
print('addition a fait')
print(expression_traite)
else:
if faire_loperation_sur_la_dernier_expression:
expression_traite.append('.')
faire_loperation_sur_la_dernier_expression = False
continue
automate_correspondant = GenerateurAutomate.a_partir_du_symbole(symbole)
symbole_vers_automate[f'{symbole}{index_suivant - 1}'] = automate_correspondant
expression_traite.append(f'{symbole}{index_suivant - 1}')
expression_traite.append('.')
print('Concat a fais')
print(expression_traite)
taken = False
addition = False
concat = False
dernier_expression = None
counter = -1
expression_traite_normal = []
exp_precedent = None
for expression in expression_traite:
if expression != exp_precedent:
expression_traite_normal.append(expression)
exp_precedent = expression
#reduction des plus
automate_precedent =None
print(f"Expression normal = {expression_traite_normal}")
automata_traite = []
dois_additioner = False
for expression in expression_traite_normal:
if expression == '+':
dois_additioner = True
continue
if expression == '.':
continue
elif dois_additioner:
automata_traite[-1] = GenerateurAutomate.faire_union(automata_traite[-1], symbole_vers_automate[expression])
dois_additioner = False
continue
else:
automata_traite.append(Automate.a_partir_de(symbole_vers_automate[expression]))
#Faire la concat
taken = False
for automate in automata_traite:
if not taken:
resultat = Automate.a_partir_de(automate)
taken = True
else:
resultat = GenerateurAutomate.faire_la_concatenation(Automate.a_partir_de(resultat), automate)
return resultat
print(f"Expression normal = {expression_traite_normal}")
for expression in expression_traite_normal:
counter += 1
#symbole_vers_automate[expression].visualiser()
if expression == '.':
concat = True
elif expression == '+':
addition = True
concat = False
elif not taken:
resultat = symbole_vers_automate[expression]
taken=True
dernier_expression = Automate.a_partir_de(resultat)
else:
if concat :
concat = False
resultat = GenerateurAutomate.faire_la_concatenation(Automate.a_partir_de(resultat), symbole_vers_automate[expression])
elif addition:
addition = False
resultat = GenerateurAutomate.faire_union(Automate.a_partir_de(resultat),
symbole_vers_automate[expression])
#resultat.visualiser()
return resultat
print(f"Nom {x}")
if x == nom:
self.liste_automate[x].copie_automate(self.automate)
print(
[self.liste_automate[a].etat_initial for a in self.liste_automate])
alphabet = Alphabet([])
a = Etat('a')
b = Etat('b')
c = Etat('c')
t1 = Transition(a, '1', b)
t2 = Transition(a, '1', a)
t3 = Transition(a, '2', b)
t4 = Transition(b, '1', b)
automata = Automate(alphabet, [], None, [], [])
automata.definir_nom('Sans Nom')
liste_automate = {'Sans Nom': Automate.a_partir_de(automata)}
def run_app(automate=automata):
import sys
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow(automata, liste_automate)
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())