2. TP 1 Présentation de Jess
Exercice d’application
Suppose you wanted to write an expert system to determine how a mobile robot should
respond to a traffic light. The rules for the red and green light situations can be written as
follows.
(defrule red-light
(light red)
=>
(printout t "STOP" crlf)
)
(defrule green-light
(light green)
=>
(printout t "GO" crlf)
)
1. For all questions Write a command and describe what you see?
After the rules have been entered into Jess, assert a fact (light red) and run.
Jess>defrule red-light
(light red)
=>
(printout t "STOP" crlf)
)
Jess>(defrule green-light
(light green)
=>
(printout t "GO" crlf)
)
Jess>(assert (light red))
Jess>(run)
2. Watch fact
Jess> (watch facts)
TRUE
Jess> (reset)
==> f-0 (MAIN::initial-fact)
TRUE
Jess> (unwatch facts)
TRUE
3. Retract fact (light red) and run
Jess> (retract 1)
Jess> (facts)
2
4. 5. Create a Button in the Jess Language who “run” these rules.
Jess> (import java.awt.*)
Jess> (import java.awt.event.*)
Jess> ;; Create the widgets
(defglobal ?*f* = (new Frame "Button Demo"))
Jess> (defglobal ?*b* = (new Button "Hello"))
Jess> ;; Add a listener to the button
(?*b* addActionListener (implement ActionListener using (lambda (?name ?evt)
(run))))
Jess> ;; Assemble and display the GUI
(?*f* add ?*b*)
Jess> (?*f* pack)
Jess> (set ?*f* visible TRUE)
Jess> ;; Add a WINDOW_CLOSING listener
(import java.awt.event.WindowEvent)
(?*f* addWindowListener (implement WindowListener using (lambda (?name ?event)
(if (= (?event getID) (WindowEvent.WINDOW_CLOSING)) then
(exit)))))
4
5. TP 2 : Arbre généalogique
1) Comment faut-il modifier la première prémisse de chacune des 4 règles de calcul
d’ancêtre pour sélectionner l’individu à étudier ? Faites une exécution.
(deftemplate individu
(slot nom)
(slot pere)
(slot mere)
(slot a_etudier (default non))
)
((defrule startup
?f<-(initial-fact)
=>
(printout t "Indiquez l'individu dont vous recherchez un ancêtre (ou
tapez fin pour arrêter) : ")
(bind ?x (sym-cat (readline)))
(assert (a_etudier ?x))
(retract ?f)
)
(defrule a_etudier
(a_etudier ?x)
?f<-(individu (nom ?x)(a_etudier non))
=>
(modify ?f (a_etudier oui))
)
(defrule ancetresinconnus
(a_etudier ?x)
(individu (nom ?x)(pere nil)(mere nil))
=>
(printout t ?x " n'a pas d'ancêtres connus" crlf)
)
(defrule imprime
(declare (salience -10))
(a_etudier ?y)
(ancetre ?x ?y)
=>
(printout t ?x " est un ancetre de " ?y crlf)
5
6. )
2) Ecrire une règle qui permette de redemander un nom à l’utilisateur si jamais celui-ci a
indiqué un nom ne figurant pas dans la famille. Quelle priorité faut-il donner à cette règle
?
(defrule control_choix
(declare (salience 500))
(a_etudier ?x)
(not ( individu (nom ?x)))
=>
(printout t "Vous devez choisir un nom qui existe!" crlf)
)
3) Ecrire une règle permettant de stopper le moteur d’inférences si l’utilisateur indique «
fin » comme nom d’utilisateur. Quelle priorité faut-il donner à cette règle ?
(defrule control_fin
(declare (salience 700))
6
7. (a_etudier fin)
=>
(exit))
4) Ecrire une règle qui permette de demander un nouvel individu à l’utilisateur après que
le système ait affiché tous les ancêtres de l’individu précédent. Quelle priorité faut-il
donner à cette règle ?
(defrule selctionner
(declare (salience -20))
=>
(printout t "Indiquez l'individu dont vous recherchez un ancêtre (ou
tapez fin pour arrêter) : ")
(bind ?x (sym-cat (readline)))
(assert (a_etudier ?x))
(run_boucle)
)
(deffunction run_boucle()
(reset)
(run)
)
Exercice pratique :
(deftemplate droite
(slot a)
(slot b)
(slot c)
)
(deftemplate point
(slot x)
(slot y)
)
(defrule startup
=>
(printout t "entrez les coordonnées de votre droite : ")
7
8. (bind ?x1 (sym-cat (readline)))
(bind ?y1 (sym-cat (readline)))
(bind ?z1 (sym-cat (readline)))
(assert (droite (a ?x1) (b ?y1) (c ?z1)))
(printout t "entrez les coordonnées du point : ")
(bind ?x2 (sym-cat (readline)))
(bind ?y2(sym-cat (readline)))
(assert (point (x ?x2) (y ?y2)))
)
(defrule calcul_distance
(droite (a ?x1 )(b ?y1) (c ?z1))
(point (x ?x2) (y ?y2))
=>
(calcul a b c x y)
)
(deffunction calcul (?a ?b ?c ?x ?y)
(bind ?result (/ (+ (+ (* ?a ?x) (* ?b ?y)) c) (+ (* ?a ?a) (* ?b ?b))))
(return ?result)
)
(reset)
(run)
8
9. TP 3
Dans ce TP nous allons utiliser la programmation en jess pour crée dans une première
application un jeu très connu qui celui du « tictac » et dans une seconde application nous allons
traiter des calculs mathématiques que nous avons pris l’habitude de traiter couramment en java
ou encore en C++.
1) Vous essayez d’exécuter le fichier « tictac.clp » avec l’instruction (batch nomfichier)
Jess> (batch tictac.clp)
2) Le programme ne s’arrête pas dans le cas où il n’y a pas de gagnant et toutes les cases
sont remplies. Améliorer le code en ajoutant une règle à priorité réduite traitant ce cas.
(defrule check-notwin-backslash
(declare (salience 10))
(case 1 1 ?a)
(case 1 2 ?b)
(case 2 2 ?a)
(case 3 2 ?a)
(case 2 1 ?b)
(case 1 3 ?a)
(case 3 1 ?b)
(case 2 3 ?b)
(case 3 3 ?b)
(test (neq ?a _))
(test (neq ?b _))
9
10. =>
(printout t "Aucun gagneur " crlf "Fin de la partie..." crlf)
(halt)
)
3) Ajouter une règle permettant de demander si le joueur veut rejouer ou non.
(deffunction run_n_time(?rep)
(while (test (neq ?rep n)) do
((reset)
(run)
(printout t "Voulez vous rejouez?")
(bind ?rep (read))
)
)
)
10
11. TP 4
; soduko.clp
; Fait par Sébastien Gagné
; Pour le cours de LOG625
;
; Utilisation : charger le fichier dans Jess
; Pour jouer son coup, il faut entrer la ligne et la colone avec un espace entre les
deux.
;
; 2008-05-28 : Version initiale
(clear)
; === Faits de base ===
; Les cases
(deffacts cases
(case 1 1 _)
(case 1 2 _)
(case 1 3 _)
(case 2 1 _)
(case 2 2 _)
(case 2 3 _)
(case 3 1 _)
(case 3 2 _)
(case 3 3 _))
; Pour chager de case facilement
(deffacts prochain-joueur
(next X X)
)
;=== Règles ===
;Init rule
;Le read ici est pour que les readline suivants fonctionnent
(defrule startup
(declare (salience 60))
=>
(printout t "Voulez vous jouer (O/N) ? " crlf)
(bind ?x (read))
(if(= ?x n) then (halt)
else(while (eq ?x o) do
(assert (tour X))
(assert (show-grid))
(run)
(printout t "Voulez vous jouer (O/N) ? " crlf)
(bind ?x (read))
(reset)
)
(halt)
)
)
; Demander le coup du joueur
(defrule do-move
11