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_())