print b1
b2 = aut3.accepte(aut3, "abbaaa")
print b2
wait = raw_input("\nTo proceed press return!\n")
print("Méthode estComplete")
b3 = aut3.estComplet(aut3, aut3.getAlphabetFromTransitions())
print b3
b4 = aut0.estComplet(aut0, aut0.getAlphabetFromTransitions())
print b4
wait = raw_input("\nTo proceed press return!\n")
print("Méthode estDeterministe")
b5 = aut3.estDeterministe(aut3)
print b5
b6 = aut0.estDeterministe(aut0)
print b6
wait = raw_input("\nTo proceed press return!\n")
print("Méthode completeAutomate")
aut1compl = aut1.completeAutomate(aut1, aut1.getAlphabetFromTransitions())
print aut1compl
""" [0(init)-a->1] [1-a->0(init)] [1-b->2(fin)] [2(fin)-b->2(fin)]
[0(init)-b->Puit] [2(fin)-a->Puit] [Puit-a->Puit] [Puit-b->Puit]"""
aut1compl.show("A1-complete")
wait = raw_input("\nTo proceed press return!\n")
# Test fonction estComplet
if Automate.estComplet(auto1, "ab"):
print("L'automate est complet pour l'alphabet ab")
else:
print("L'automate n'est pas complet pour l'alphabet ab")
if Automate.estComplet(auto1, "abc"):
print("L'automate est complet pour l'alphabet abc")
else:
print("L'automate n'est pas complet pour l'alphabet abc")
# Test fonction estDeterministe
if Automate.estDeterministe(auto1):
print("L'automate est deterministe")
else:
print("L'automate n'est pas deterministe")
t1_ = Transition(s0, 'a', s2)
t2_ = Transition(s0, 'b', s2)
nondeter = Automate([t1, t2, t3, t1_, t2_, t4])
# nondeter.show("Non_deterministe")
if Automate.estDeterministe(nondeter):
print("L'automate est deterministe")
else:
print("L'automate n'est pas deterministe")
# Test fonction completeAutomate
if Automate.accepte(auto1,"abb"):
print("L'automate accepte le mot abb\n")
else:
print("L'automate n'accepte pas le mot abb\n")
if Automate.estComplet(auto,{"a","b"}):
print("L'automate est complet\n")
print(auto)
else:
print("L'automate n'est pas complet\n")
print(Automate.completeAutomate(auto,{"a","b"}))
if Automate.estDeterministe(auto1):
print("L'automate est déterministe\n")
else:
print("L'automate n'est pas déterministe\n")
auto3 = Automate.creationAutomate("auto3.txt")
print(auto3)
if Automate.estDeterministe(auto3):
print("L'automate est déterministe\n")
else:
print("L'automate n'est pas déterministe\n")
print(Automate.determinisation(auto3))
Automate.determinisation(auto3).show("A3_listeTrans")
print a.succ(list,"c")
print a.succ(list,"b")
print "etats accessibles"
print a.acc()
print Automate.accepte(a, "abc")
print Automate.accepte(a, "aaabbcb")
print Automate.accepte(a, "abs")
"""
"""
print Automate.estComplet(a,["a","b","c"])
print Automate.estComplet(a, ["0","1"])
print Automate.estComplet(a, ["a","b"])
"""
print("Deterministe")
print(Automate.estDeterministe(a))
#b=Automate.completeAuto(a,["a","b","c"])
#a.show("automate_a")
#b.show("b=a_aprescompletion")
#print b
"""
print b.getAlphabetFromTransitions()
print "etats accessibles"
print b.acc()
print Automate.accepteVide(b)
#b.show("automate_b")
print "determinisation"
c = Automate.determinisation(b)
#c.show("Determinisationb")
print "\n******************************************************\n"
print "******************************************************\n"
print "Test de la méthode estComplet\n"
print "Automate.estComplet(a, [\"a\", \"b\", \"c\"]) : "
print Automate.estComplet(a, ["a", "b", "c"])
print "\n Automate.estComplet(a, [\"0\", \"1\"]) : "
print Automate.estComplet(a, ["0", "1"])
print "\n Automate.estComplet(a, [\"a\", \"b\"]) : "
print Automate.estComplet(a, ["a", "b"])
print "\n******************************************************\n"
print "******************************************************\n"
print "Test de la méthode estDeterministe\n"
print "Automate.estDeterministe(a) :\n"
print Automate.estDeterministe(a)
print "\nAutomate.estDeterministe(b) :\n"
print Automate.estDeterministe(b)
print "\n******************************************************\n"
print "******************************************************\n"
print "Test de la méthode completeAutomate\n"
print "Automate.completeAutomate(a, [\"a\", \"b\", \"c\"]) : \n"
k = Automate.completeAutomate(a, ["a", "b", "c"])
print k
## Création du pdf
#k.show("completA")
print "\n******************************************************\n"
print "********************************************************\n"
print "Test de la méthode determinisation\n"
if res == True:
print "L'automate est complet."
else:
print "L'automate n'est pas complet."
print("\n APRES UTILISATION DE completeAutomate\n")
complete = Automate.completeAutomate(autoA, autoA.getAlphabetFromTransitions())
res = Automate.estComplet(complete, complete.getAlphabetFromTransitions())
if res == True:
print "L'automate est complet."
else:
print "L'automate n'est pas complet."
#complete.show("autocomplete")
print "\n TEST 'estDeterministe' \n"
res = Automate.estDeterministe(autoA)
if res == True:
print "L'automate est déterministe."
else:
print "L'automate n'est pas déterministe."
print "\n TEST 'determinisation' \n"
deter = Automate.determinisation(autoA)
print("\n APRES UTILISATION DE 'determinisation'\n")
res = Automate.estDeterministe(deter)
if res == True:
print "L'automate est déterministe."
else:
print "L'automate n'est pas déterministe."
def main():
### EXERCICE 2
# Création des états et des transitions
s0 = State(0, True, False)
s1 = State(1, False, False)
s2 = State(2, False, True)
t1 = Transition(s0, "a", s1)
t2 = Transition(s0, "b", s1)
t3 = Transition(s1, "a", s2)
t4 = Transition(s1, "b", s2)
t5 = Transition(s2, "a", s0)
t6 = Transition(s2, "b", s1)
# On crée l'automate 0 à partir de transitions
auto = Automate([t1, t2, t3, t4, t5, t6])
print(auto)
# On crée l'automate 1 à partir de transitions et d'états (auto et auto1 sont identiques)
auto1 = Automate([t1, t2, t3, t4, t5, t6], [s0, s1, s2])
print(auto1)
# On crée l'automate 2 à partir d'un fichier
auto2 = Automate.creationAutomate("exempleAutomate.txt")
print(auto2)
"""# On print l'automate 0 dans un pdf
auto.show("auto_ListeTrans")
# On print l'automate 0 dans un pdf
auto1.show("auto1_ListeTrans")
# On print l'automate 0 dans un pdf
auto2.show("auto2_ListeTrans")"""
# TRAVAIL SUR L'AUTOMATE 0
# On supprime une transition (t1) et on affiche le résultat
auto.removeTransition(t1)
print(auto)
# On rajoute la transition supprimée et on affiche le résultat
auto.addTransition(t1)
print(auto)
# On supprime l'état 1 (s1) de l'automate 0 et on affiche le résultat
auto.removeState(s1)
print(auto)
# On ajoute l'état 1 (s1) de l'automate 0 et on affiche le résultat
auto.addState(s1)
print(auto)
# On affiche les transitions de l'automate 0
print(auto.getListTransitionsFrom(s1))
print()
### EXERCICE 3
# On récupère l'automate auto1 pour effectuer les tests
print("\nTest de la fonction succ sur auto1\n")
print(auto1.succ([s0, s1, s2], "a"))
print()
# On vérifie si un mot est accepté ou non par l'automate auto1
print("\nLes mots sont-ils acceptés par auto1\n")
print("L'automate auto1 accepte-t-il le mot '' : " +
str(Automate.accepte(auto1, "")))
print("L'automate auto1 accepte-t-il le mot 'aababaabbba' : " +
str(Automate.accepte(auto1, "aababaabbba")))
print()
# On vérifie si les automates auto1 et auto2 sont complets
print("\nLes automates sont-ils complets ?\n")
print("L'automate auto1 est-il complet : " +
str(Automate.estComplet(auto1, auto1.getAlphabetFromTransitions())))
print("L'automate auto2 est-il complet : " +
str(Automate.estComplet(auto2, auto2.getAlphabetFromTransitions())))
print()
# On vérifie si les automates auto1 et auto2 sont déterministes
print("Les automates sont-ils déterministes ?\n")
print("L'automate auto1 est-il déterministe : " +
str(Automate.estDeterministe(auto1)))
print("L'automate auto2 est-il déterministe : " +
str(Automate.estDeterministe(auto2)))
print()
# On complète l'automate auto2
#auto2.show("Avant_la_completion.pdf")
new_auto2 = Automate.completeAutomate(copy.deepcopy(auto2),
auto2.getAlphabetFromTransitions())
#new_auto2.show("Apres_la_completion.pdf")
ss0 = State(0, True, False)
ss1 = State(1, True, False)
ss2 = State(2, False, False)
ss3 = State(3, False, True)
tt1 = Transition(ss0, "a", ss0)
tt2 = Transition(ss0, "b", ss0)
tt3 = Transition(ss0, "b", ss1)
tt4 = Transition(ss1, "a", ss2)
tt5 = Transition(ss2, "b", ss3)
# On effectue des tests avec la fonction complementaire
autotest = Automate([tt1, tt2, tt3, tt4, tt5])
print(autotest)
#autotest.show("autotest_avant_comp")
new_autotest2 = Automate.complementaire(
autotest, autotest.getAlphabetFromTransitions())
print(new_autotest2)
#new_autotest2.show("resulat_comp")
# On effectue des tests sur un automate provenant d'un sujet de partiel
print("\nTest sur l'examen\n")
so1 = State(1, True, False)
so2 = State(2, False, False)
so3 = State(3, False, True)
to1 = Transition(so1, "a", so1)
to2 = Transition(so1, "a", so2)
to3 = Transition(so2, "a", so3)
to4 = Transition(so2, "b", so2)
to5 = Transition(so3, "b", so3)
to6 = Transition(so3, "b", so2)
to7 = Transition(so3, "a", so1)
auto3 = Automate([to1, to2, to3, to4, to5, to6, to7], [so1, so2, so3])
print(auto3)
#auto3.show("Automate_Examen")
print("\nL'automate auto3 est-il complet ? " +
str(Automate.estComplet(auto3, auto3.getAlphabetFromTransitions())) +
"\n")
auto3_comp = Automate.completeAutomate(copy.deepcopy(auto3),
auto3.getAlphabetFromTransitions())
print("\nL'automate auto3_comp est-il complet ? " + str(
Automate.estComplet(auto3_comp,
auto3_comp.getAlphabetFromTransitions())) + "\n")
#auto3_comp.show("Automate_Examen_Complété")
auto3_n = Automate([to1, to2, to3, to4, to5, to6, to7], [so1, so2, so3])
print("\nL'automate auto3_n est-il déterministe ? " +
str(Automate.estDeterministe(auto3_n)) + "\n")
auto3_det = Automate.determinisation(auto3_n)
print("\nL'automate auto3_det est-il déterministe ? " +
str(Automate.estDeterministe(auto3_det)) + "\n")
#auto3_det.show("Automate_Examen_Determinise")
print("\nL'automate complémentaire de l'automate auto3 de base\n")
auto3_complementaire = Automate.complementaire(
copy.deepcopy(auto3),
copy.deepcopy(auto3).getAlphabetFromTransitions())
print(auto3_complementaire)
#auto3_complementaire.show("post_complementaire")
# On utilise la fonction de concatenation entre deux automates
prime1 = State(0, True, False)
prime2 = State(1, False, True)
prime3 = State(2, True, False)
prime4 = State(3, False, True)
tprime1 = Transition(prime1, "a", prime2)
tprime2 = Transition(prime2, "b", prime2)
tprime3 = Transition(prime3, "c", prime3)
tprime4 = Transition(prime3, "a", prime4)
auto_exam1 = Automate([tprime1, tprime2])
auto_exam2 = Automate([tprime3, tprime4])
auto_exam_c = Automate.concatenation(auto_exam1, auto_exam2)
print(auto_exam_c)
# On utilise la fonction d'union entre deux automates
st1 = State(1, True, False)
st2 = State(2, False, True)
tr1 = Transition(st1, "a", st1)
tr2 = Transition(st1, "b", st2)
tr3 = Transition(st2, "a", st2)
auto_st_tr1 = Automate([tr1, tr2, tr3])
st3 = State(3, True, False)
st4 = State(4, False, True)
tr4 = Transition(st3, "a", st4)
tr5 = Transition(st3, "b", st4)
tr6 = Transition(st3, "c", st4)
tr7 = Transition(st4, "a", st4)
auto_st_tr2 = Automate([tr4, tr5, tr6, tr7])
auto_test_union = Automate.union(copy.deepcopy(auto_st_tr1),
copy.deepcopy(auto_st_tr2))
print(auto_test_union)
# On utilise la fonction d'intersection entre deux automates
auto_test_intersection = Automate.intersection(copy.deepcopy(auto_st_tr1),
copy.deepcopy(auto_st_tr2))
print(auto_test_intersection)
target = True
if test == target:
cpt = cpt+1
else:
print("- Fail test 4 : renvoie", test, "au lieu de", target)
test = auto1.estComplet(auto5,"ab")
target = True
if test == target:
cpt = cpt+1
else:
print("- Fail test 5 : renvoie", test, "au lieu de", target)
print(cpt, "tests sur 5 réussis.")
# fonction estDeterministe
if auto1.estDeterministe(auto1) == None:
print("estDeterministe non définie")
else:
print("Tests fonction estDeterministe:")
cpt = 0
test = auto1.estDeterministe(auto1)
target = True
if test == target:
cpt = cpt+1
else:
print("- Fail test 1 : renvoie", test, "au lieu de", target)
test = auto1.estDeterministe(auto2)
target = True
if test == target:
cpt = cpt+1
else:
print (Automate.accepte(a, "abs"))
print (Automate.accepte(c, "abc"))
print (Automate.accepte(c, "aaabbcb"))
print (Automate.accepte(c, "abcs"))
a.show("hey.pdf")
a.show("salut")
print (Automate.estComplet(a,["a","b","c"]))
print (Automate.estComplet(a, ["0","1"]))
print (Automate.estComplet(a, ["a","b"]))
print (Automate.estComplet(c,["a","b","c"]))
print ("\nDeterministe\n")
print (Automate.estDeterministe(a))
print (Automate.estDeterministe(b))
print (Automate.estDeterministe(c))
print (Automate.estDeterministe(d))
e=Automate.completeAutomate(a,["a","b"])
a.show("automate_a")
e.show("e=a_aprescompletion")
print(e)
print("Determinisation")
f = Automate.determinisation(b)
f.show("Determinisationb")
G = Automate.determinisation(d)
d.show("Determinisationd")