02-Programmation Fonctionnelle - Le Lisp
02-Programmation Fonctionnelle - Le Lisp
02-Programmation Fonctionnelle - Le Lisp
Fonctionnelle
- Le Lisp -
www.supinfo.com
Copyright © SUPINFO. All rights reserved
Programmation Fonctionnelle - Le Lisp -
Votre formateur…
Titre: Professeur Référent en IA
Distinctions & expérience:
Enseignement et recherche en
Intelligence Artificielle, Informatique
et Electronique. Participation à des
congrès internationaux en
Intelligence Artificielle
Formation: Doctorat en Intelligence
Artificielle. Ingénieur en
télécommunications.
Publications: 60 articles,
communications et livres dont 48 sur
l’IA
Marianne BELIS Contact:
marianne.belis@supinfo.com
SUPINFONE: 1 317
Programmation Fonctionnelle - Le Lisp -
Votre formateur…
Titre: Professeur Référent en
Algorithmique, Théorie des Graphes et
Intelligence Artificielle.
Distinction: Mastaire en Recherche
Opérationnelle et Intelligence Artificielle.
Formation: Ingénieur en Informatique,
Conception et Développement,
(modélisation, optimisation, simulation,
complexité et algorithmique). Qualifié en
Gestion des Risques (spécialisé en
modélisation et Systèmes d'Information)
Publication: « La simulation des flux de
transports de marchandises en
agglomération » (2002).
Arnaud CUEILLE
Contact:
Arnaud.CUEILLE@supinfo.com
SUPINFONE: 1 50087
Programmation Fonctionnelle - Le Lisp -
Objectifs de ce module
En suivant ce module vous allez:
Aborder la programmation
fonctionnelle.
Maîtriser les principales
primitives du langage LISP.
Lire et comprendre le
fonctionnement de programmes
en LISP.
Ecrire des fonctions simples,
maîtriser le concept de récursivité
avec des listes.
Utiliser le Lisp dans des
applications d’IA comme les
système expert, la sortie d’un
labyrinthe ou le jeu du taquin.
Programmation Fonctionnelle - Le Lisp -
Plan du module
Voici les parties que nous allons aborder:
Fonctions complexes.
Opérations symboliques.
Programmation Fonctionnelle - Le Lisp -
Généralités, éléments de
base
Généralités, éléments de base
Plan de la partie
Voici les chapitres que nous allons aborder:
Présentation
Les expressions symboliques
Fonctions arithmétiques élémentaires
Les fonctions primitives
Les prédicats
Fonctions d'affectation et d'évaluation
Représentation graphique des listes
Les fonctions d'entrée/sortie
L’environnement de programmation
Généralités, éléments de base
Présentation
Origine du langage Lisp.
Son concepteur :
John Mc CARTHY
Création en 1960
Spécificités du Lisp
Langage
fonctionnel*
Traitement
symbolique**
Le code est formé
de listes
parenthésées*** John Mc CARTHY
Généralités, éléments de base
Présentation
Historique des principaux langages, dont le Lisp.
Présentation
Historique des dialectes Lisp .
Présentation
Spécificités du langage fonctionnel Lisp
Syntaxe simple mais parenthèses multiples
Langage interprété***
Généralités, éléments de base
Présentation
Impression du
résultat
Généralités, éléments de base
Les atomes
Les listes
ATOME
Expression symbolique élémentaire.
C’est une S-EXPRESSION insécable*
Généralités, éléments de base
Les noms :
Un caractère
ex: a
Suite de caractères
sans séparateur
ex: supinfo
Les nombres :
Nombres positifs
Nombres négatifs
Généralités, éléments de base
a
B
ATOME
Pierre
Atome-Long
unseulatomelong
128
-345
*86
49CE+
Généralités, éléments de base
I O N !
AT TENT
i s t e u n
il ex
a t o m e
ic u li e r
part L !
N I
appelé
i v r e …
à su
Généralités, éléments de base
SÉPARATEUR
Caractère qui permet de séparer les
expressions.
Généralités, éléments de base
Le point : .
L’espace
Les parenthèses : ( et )
Les crochets : [ et ]
L’apostrophe : quote ou ’
La tabulation
Le point-virgule : ;
Le retour chariot (return)
Généralités, éléments de base
T I O N !
ATT E N
s t e u n
Il exi r
a t e u
sépar : l e
t ic u l ie r
par
t < .> !
poin
i v r e …
à su
Généralités, éléments de base
LISTE
S-EXPRESSION
Suite ordonnée d’atomes ou de listes
Généralités, éléments de base
Paire pointée
Une paire pointée est spécifiée par
l'utilisation du séparateur point <.> situé
entre deux objets.
ex.: (A . B)
Généralités, éléments de base
Le premier Le dernier
élément est élément est
précédé d'une suivi d'une
parenthèse. parenthèse.
1er élément 3ème élément
(A B C)
2ème élément
Le second
élément est
encadré de
séparateurs, ici
un espace.
Généralités, éléments de base
2ème niveau
Le second élément
(l’atome “liste”) est
au second niveau:
profondeur 1.
Généralités, éléments de base
… … )
(…
n t h è s e s
p a r e
Les u ti l i s é e s
u s s i
sont a u e r l e
m a r q
pour a f i n d e
t e t l
débu n e
l d ' u
l'appe
t io n .
fonc
Généralités, éléments de base
… … )
n c t i o n
(fo
m d e l a
Le no s t p l a cé
i o n e
fonct p r è s l a
o u r s a
touj e o u v r a n te
r e n t h è s
pa e l e s
p r é c è d
et .
e n t s
argum
Généralités, éléments de base
L'addition :
(+ … …)
La soustraction :
(- … …)
La multiplication :
(* … …)
La division :
(/ … …)
Généralités, éléments de base
FONCTIONS RESULTAT
?(+ 2 3) = 5
?(- 13 7 2) = 4
?(* 5 11) = 55
?(/ 15 3) = 5
?(+ (* 5 4) (* 2 3)) = 26
Généralités, éléments de base
QUOTE
CAR
CDR
CONS
APPEND
Généralités, éléments de base
QUOTE
Empêche l’évaluation de l'expression
symbolique fournie en argument.
Retourne l’expression non évaluée.
Exemple:
? (quote (2 + 3))
= (2 + 3)
Généralités, éléments de base
Nom de la fonction
(quote <argument>)
Argument
Généralités, éléments de base
?(quote (+ 2 3)) = (+ 2 3)
? ‘(+ 2 3 4) = (+ 2 3 4)
?′(- 5 3) = (- 5 3)
?′(* 2 3 2) = (* 2 3 2)
?′(/ 21 7) = (/ 21 7)
?(/ 21 7) = 3
Généralités, éléments de base
CAR
Extrait le premier élément d’une liste.
Celui-ci peut être un atome ou une liste.
Généralités, éléments de base
Nom de la fonction
(car <argument>)
Argument
L'argument doit
être une liste
Généralités, éléments de base
CDR
Retourne une liste privée de son
premier élément.
Généralités, éléments de base
Nom de la fonction
(cdr <argument>)
Argument
L'argument doit
être une liste.
Généralités, éléments de base
?(cdr '(12)) = ()
Généralités, éléments de base
L'argument doit
être une liste.
Généralités, éléments de base
s tu c e s …
s e t a
Truc
e l i r e
Afin d u n e
t e m e n t
corre c
a t i o n d e
im b r i c
c t i o n s ,
fon a r
e n c e z p
co m m n
s c r it e e
celle i n
d e u r !
profon
Généralités, éléments de base
CADR
Permet d'extraire le second élément de
la liste fournie en argument.
Exemple: (cadr ‘(a b c)) = (car (cdr ‘(a b c))) = (car ‘(b c)) = b
Généralités, éléments de base
CADDR
Permet d'extraire le troisième élément de
la liste fournie en argument.
Exemple: (car (cdr (cdr ‘(a b c)))) = (car (cdr ‘(b c))) = (car ‘(c)) = c
Généralités, éléments de base
FONCTIONS RESULTAT
CONS
Ajoute un élément en tête d’une liste
Généralités, éléments de base
Nom de la fonction
Arguments
Le nombre
d'arguments est fixe
et égal à deux.
Généralités, éléments de base
APPEND
Permet de concaténer les listes
transmises en argument.
Généralités, éléments de base
Nom de la fonction
Arguments
Généralités, éléments de base
Les prédicats
Quelques prédicats usuels:
ATOM
CONSP
NULL
EQUAL
NUMBERP
< ou > ou <= ou >=
Généralités, éléments de base
Les prédicats
ATOM
Teste si l'argument est un atome.
Retourne t (ou vrai) si ce test est
vérifié, ( ) dans le cas contraire.
Généralités, éléments de base
Les prédicats
Appel de la fonction ATOM
Nom de la fonction
(atom <argument>)
Argument
Généralités, éléments de base
Les prédicats
CONSP
Teste si l'expression est une liste.
Retourne l'expression si le test est
vérifié, ( ) dans le cas contraire.
Généralités, éléments de base
Les prédicats
Appel de la fonction CONSP
Nom de la fonction
(consp <argument>)
Argument
Généralités, éléments de base
Les prédicats
NULL
Teste si l'expression est égale à ( ).
Retourne t (vrai) si le test est vérifié, ( )
dans le cas contraire.
Généralités, éléments de base
Les prédicats
Appel de la fonction NULL
Nom de la fonction
(null <argument>)
Argument
Généralités, éléments de base
Les prédicats
EQUAL
Vérifie l’égalité de ses deux arguments.
Retourne t (vrai) si le premier argument
est égal au second, ( ) (ou NIL) dans le
cas contraire.
Généralités, éléments de base
Les prédicats
Appel de la fonction EQUAL
Nom de la fonction
Argument
Généralités, éléments de base
Les prédicats
NUMBERP
Teste si l'argument est un nombre.
Retourne le nombre si le test est vérifié,
( ) (ou NIL) dans le cas contraire.
Généralités, éléments de base
Les prédicats
Appel de la fonction NUMBERP
Nom de la fonction
(numberp <argument>)
Argument
Généralités, éléments de base
Les prédicats
Les prédicats
Appel des fonctions <, >, <=, >=
Nom de la fonction
Arguments
Généralités, éléments de base
Les prédicats
Exemples
FONCTION RESULTAT
?(atom ‘pierre) = t
?(null ()) = t
?(numberp ‘a) = ()
SETQ
LET
Généralités, éléments de base
SETQ
Affecte aux symboles la valeur de
l'évaluation des expressions.
Les symboles conservent la valeur des
expressions après l'appel.
Généralités, éléments de base
Nom de la fonction
Arguments
Généralités, éléments de base
?(setq a 3) = 3
?(+ a 6) = 9
?(setq b (+ 3 4)) = 7
?(setq c (+ a b)) = 10
?(setq x 2 y 3) = 3
?(* x y) = 6
Généralités, éléments de base
LET
Retourne la valeur d’une fonction dont
les variables ont des valeurs locales à
LET.
Exemple : ( let ( (a 2) (b 3) ) (+ a b) ) = 5
Généralités, éléments de base
Nom de la fonction
interne à LET
? a = 13
? b = 27
? a = 13
? b = 27
1 4
1 Profondeur 0.
2 5
2 Profondeur 1.
3 Profondeur 2.
4 Racine.
5 Sommet.
6 Feuille.
3 7
7 Arête. 6
Généralités, éléments de base
Profondeur 0 :
()
Profondeur 1 :
A
B
A B
Généralités, éléments de base
Profondeur 0 :
()
Profondeur 1 :
()
B
( ) B
Profondeur 2 :
1
1 2 3
2
3
Généralités, éléments de base
D
E
F
Généralités, éléments de base
D
6 D E
E
Généralités, éléments de base
s tu ce s …
s e t a
Truc
e n e p a s
A f i n d s u r
'e r r e u r
faire d d e
i c a t i o n s
le s i m b r
t h è s e s ,
p a r e n !
t e z - l e s
num é r o
Généralités, éléments de base
À chaque parenthèse 4
F
ouvrante, indicer en
incrémentant : 0(1
5
À chaque parenthèse
fermante, indicer en 6 D E
décrémentant : 1)0
Généralités, éléments de base
(ou) erreur
3 A B C H
d'indice
L'indice indique le 4
niveau des atomes grâce F
au numéro qui l'encadre
5
ex.: G, au niveau 1
ex.: A, B, C et H, au 6 D E
niveau 3
Généralités, éléments de base
1
Fonction CAR appliquée à la liste
2
initiale.
Fonction CDR appliquée à la liste
3 2 (A (B C) D E) 3
initiale.
La fonction CAR a extrait le premier
4
élément de la liste. (car ‘(A(BC)DE)) (cdr ‘(A(BC)DE))
(A (B C) D E)
A ((B C) D E)
(B C) (D E)
B (C) D (E)
C NIL E NIL
Généralités, éléments de base
READ
PRINCH
TERPRI
Généralités, éléments de base
READ
Lit l'expression suivante de type
quelconque (atome ou liste) sur le flux
d'entrée courant.
Retourne la valeur de l'expression
entrée.
Généralités, éléments de base
Nom de la fonction
(read)
Aucun argument
Généralités, éléments de base
PRINT
Edite dans le tampon de sortie les
différentes expressions transmises à la
fonction.
L'appel sans argument vide le tampon
et commence une nouvelle ligne
(retourne NIL).
Généralités, éléments de base
Nom de la fonction
Arguments
Généralités, éléments de base
PRINCH
Edite un certain nombre de fois le
caractère transmis à la fonction.
Généralités, éléments de base
Nom de la fonction
TERPRI
Provoque l'impression du tampon de
sortie.
L'appel sans argument vide le tampon et
commence une nouvelle ligne (retourne
NIL).
Dans le cas de la présence d'un argument,
celui-ci correspond au nombre de sauts de
ligne à appliquer après impression.
Généralités, éléments de base
Nom de la fonction
(terpri <nombre>)
Argument
Généralités, éléments de base
FONCTIONS RESULTAT
?(setq a (read)) ?
?le_lisp = le_lisp
? a = le_lisp
L’environnement de programmation
Editeur vidéo pleine page (nom: PEPE )
Fonction d’appel de PEPE: Ê (Ctrl E) ou:
(pepe <nom du fichier> ou (pepe (pretty <nom du fichier>))
La fonction PRETTY imprime les fonctions « joliment ».
(LOAD <nom du fichier>) charge le fichier nommé
Fonction STEP: suivi pas à pas du déroulement du programme
Fonction TRACE: suivi global du déroulement du programme
(TYCLS) pour effacer l'écran
(END) pour quitter l'interpréteur
PEPEHELP.LL (F1) affiche à l’écran les fonctions de l’éditeur
Généralités, éléments de base
Plan de la partie
Voici les chapitres que nous allons aborder:
(cond
vrai
((test1) --------------------->(action1))
faux vrai
((test 2) --------------------->(action2))
faux
.
. vrai
( T -------------------->(actions par défaut)))
Les structures de contrôle
FONCTIONS RESULTAT
?(if (numberp 1)
'(un nombre) = (un nombre)
'(pas un nombre))
?(if (numberp 'A)
'(un nombre) = (pas un nombre)
'(pas un nombre))
?(cond
((numberp 1) '(un nombre)) = (un nombre)
(T '(pas un nombre)))
?(cond
((numberp 'A) '(un nombre)) = (pas un nombre)
(T '(pas un nombre)))
Les structures de contrôle
La récursivité
La récursivité
Concept fondamental :
en mathématique :
relation de récurrence
en informatique :
procédures récursives
Les structures de contrôle
La récursivité
Le principe de la récursivité en algorithmique
La récursivité
Correspondance entre les modèles, Exemple : la factorielle
Définition récurrente :
n! = n(n - 1)!
pour n >= 1 avec 0! = 1
Algorithme récursif:
SI n = 0
ALORS réponse = 1
SINON réponse = n * fact (n - 1)
Programme LISP:
(defun fact (n)
(cond
((= n 0) 1)
(t (* n (fact (- n 1)) ) )
)
Les structures de contrôle
La récursivité
Déroulement de la fonction pour : Factorielle(3)
? (fact 3) ---- > = 6
D
E 3 * fact( 2 ) 3*2=6 E
M P
P 2 * fact( 1 ) 2*1=2 I
I L
L E
1 * fact( 0 ) 1*1=1
E R
R
=1 Retour de la Pile
Les structures de contrôle
La récursivité
Autre exemple de fonction récursive :
MEMBER : teste si un élément est présent dans une liste
(defun member (x liste)
(cond
((null liste) ())
((equal (car liste) x) liste)
(t (member x (cdr liste) ) )
)
)
L’itération
Fonctions itératives:
PROG..GO..RETURN
WHILE
Syntaxe de PROG:
(prog <liste> <S-expression1>…..<S-expression n>)
L’itération
Exemple 1: la puissance p d’un nombre n
?(defun puissance (n p)
(prog (resultat)
(setq resultat 1)
depart
(setq resultat (* n resultat))
(setq p (- p 1))
(if (= p 0)
(return resultat)
(go depart)
)
)
)
?(puissance 3 2) = 9
Les structures de contrôle
L’itération
Exemple 2: dernier élément d’une liste
L’itération
Exemple 3: inversion d’une liste
?(reverse '(a b c d) = (d c b a)
Les structures de contrôle
L’itération
Exemple 4: la variante itérative de la factorielle
?(factorielle '(3)) = 6
Les structures de contrôle
L’itération
Syntaxe de WHILE
(WHILE (condition)
(S-expression1)
(S-expression2)
………………….
(S-expression n)
)
L’itération
Exemple: affichage du décompte d’un nombre n
Fonctions complexes
Fonctions complexes
Plan de la partie
Voici les chapitres que nous allons aborder:
Les fonctionnelles
Les fonctions anonymes
Les macro fonctions
Fonctions complexes
Les fonctionnelles
FONCTIONNELLE
Fonction d'ordre supérieur qui prend les
fonctions comme argument et les
applique sur des ensembles de
données.
Fonctions complexes
Les fonctionnelles
Les fonctionnelles
MAPCAR : fonction qui retourne la liste formée des
applications de la fonction transmise en premier argument,
à tous les éléments de la liste placée en second argument.
?((lambda (x y) (* x y)) 2 3) = 6
FONCTION RESULTAT
?(if (< a 0) (1- a) (1+ a)) = (cond
((< a 0) (1- a))
(t (1+ a))
)
Fonctions complexes
FONCTION RESULTAT
?`(a b c d) = (a b c d)
? `( a b ,a a) = (a b (toto riri) a)
FONCTION RESULTAT
?(setq a `(toto riri)) =(toto riri)
?(empile a 'fifi) =(fifi toto riri)
?(empile a 'truc) =(truc fifi toto riri)
?a =(truc fifi toto riri)
?(depile a) = truc
?a = (fifi toto riri)
Fonctions complexes
Opérations symboliques
Opérations symboliques
Plan de la partie
Voici les chapitres que nous allons aborder:
chose
etre_vivant inanimé
arbre fleur insecte reptile mammifère nuage roche voiture maison ordinateur
(de cherche-sortie (I J)
(if (equal (tref labyrinthe I J) 'fin)
(setq pas-trouve ())
(tset labyrinthe I J '*)
(if (and pas-trouve
0 1 2(member (tref labyrinthe I (1+ J)) '(- fin)))
(cherche-sortie I (1+ J)))
0 *- - -
(if (and pas-trouve
(member (tref labyrinthe (1+ I) J) '(- fin)))
1 - $ $
(cherche-sortie (1+ I) J))
(if (and pas-trouve
(member (tref labyrinthe I (1- J)) '(- fin)))
2 - - fin
(cherche-sortie I (1- J)))
(if (and pas-trouve
(member (tref labyrinthe (1- I) J) '(- fin)))
(cherche-sortie (1- I) J))
(ifn pas-trouve (tset labyrinthe I J 'o)) ) )
Opérations symboliques
(de cherche-sortie (I J)
(if (equal (tref labyrinthe I J) 'fin)
(setq pas-trouve ())
(tset labyrinthe I J '*)
(if (and pas-trouve
0 1 2(member (tref labyrinthe I (1+ J)) '(- fin)))
(cherche-sortie I (1+ J)))
0 * *- -(if (and pas-trouve
(member (tref labyrinthe (1+ I) J) '(- fin)))
1 - $ $
(cherche-sortie (1+ I) J))
(if (and pas-trouve
(member (tref labyrinthe I (1- J)) '(- fin)))
2 - - fin
(cherche-sortie I (1- J)))
(if (and pas-trouve
(member (tref labyrinthe (1- I) J) '(- fin)))
(cherche-sortie (1- I) J))
(ifn pas-trouve (tset labyrinthe I J 'o)) ) )
Opérations symboliques
(de cherche-sortie (I J)
(if (equal (tref labyrinthe I J) 'fin)
(setq pas-trouve ())
(tset labyrinthe I J '*)
(if (and pas-trouve
0 1 2(member (tref labyrinthe I (1+ J)) '(- fin)))
(cherche-sortie I (1+ J)))
0 * * *-(if (and pas-trouve
(member (tref labyrinthe (1+ I) J) '(- fin)))
1 - $ $
(cherche-sortie (1+ I) J))
(if (and pas-trouve
(member (tref labyrinthe I (1- J)) '(- fin)))
2 - - fin
(cherche-sortie I (1- J)))
(if (and pas-trouve
(member (tref labyrinthe (1- I) J) '(- fin)))
(cherche-sortie (1- I) J))
(ifn pas-trouve (tset labyrinthe I J 'o)) ) )
Opérations symboliques
(de cherche-sortie (I J)
(if (equal (tref labyrinthe I J) 'fin)
(setq pas-trouve ())
(tset labyrinthe I J '*)
(if (and pas-trouve
(member (tref labyrinthe I (1+ J)) '(- fin)))
(cherche-sortie I (1+ J)))
(if (and pas-trouve
(member (tref labyrinthe (1+ I) J) '(- fin)))
(cherche-sortie (1+ I) J))
(if (and pas-trouve
(member (tref labyrinthe I (1- J)) '(- fin)))
(cherche-sortie I (1- J)))
(if (and pas-trouve
(member (tref labyrinthe (1- I) J) '(- fin)))
(cherche-sortie (1- I) J))
(ifn pas-trouve (tset labyrinthe I J 'o)) ) )
Opérations symboliques
(de cherche-sortie (I J)
(if (equal (tref labyrinthe I J) 'fin)
(setq pas-trouve ())
(tset labyrinthe I J '*)
(if (and pas-trouve
(member (tref labyrinthe I (1+ J)) '(- fin)))
(cherche-sortie I (1+ J)))
(if (and pas-trouve
(member (tref labyrinthe (1+ I) J) '(- fin)))
(cherche-sortie (1+ I) J))
(if (and pas-trouve
(member (tref labyrinthe I (1- J)) '(- fin)))
(cherche-sortie I (1- J)))
(if (and pas-trouve
(member (tref labyrinthe (1- I) J) '(- fin)))
(cherche-sortie (1- I) J))
(ifn pas-trouve (tset labyrinthe I J 'o)) ) )
Opérations symboliques
(de cherche-sortie (I J)
(if (equal (tref labyrinthe I J) 'fin)
(setq pas-trouve ())
(tset labyrinthe I J '*)
(if (and pas-trouve
0 1 2(member (tref labyrinthe I (1+ J)) '(- fin)))
(cherche-sortie I (1+ J)))
0 * * * (if (and pas-trouve
(member (tref labyrinthe (1+ I) J) '(- fin)))
*- $ $
(cherche-sortie (1+ I) J))
1 (if (and pas-trouve
(member (tref labyrinthe I (1- J)) '(- fin)))
2 - - fin
(cherche-sortie I (1- J)))
(if (and pas-trouve
(member (tref labyrinthe (1- I) J) '(- fin)))
(cherche-sortie (1- I) J))
(ifn pas-trouve (tset labyrinthe I J 'o)) ) )
Opérations symboliques
(de cherche-sortie (I J)
(if (equal (tref labyrinthe I J) 'fin)
(setq pas-trouve ())
(tset labyrinthe I J '*)
(if (and pas-trouve
0 1 2(member (tref labyrinthe I (1+ J)) '(- fin)))
(cherche-sortie I (1+ J)))
0 * * * (if (and pas-trouve
(member (tref labyrinthe (1+ I) J) '(- fin)))
* $ $
(cherche-sortie (1+ I) J))
1 (if (and pas-trouve
(member (tref labyrinthe I (1- J)) '(- fin)))
2
*- - fin (cherche-sortie I (1- J)))
(if (and pas-trouve
(member (tref labyrinthe (1- I) J) '(- fin)))
(cherche-sortie (1- I) J))
(ifn pas-trouve (tset labyrinthe I J 'o)) ) )
Opérations symboliques
(de cherche-sortie (I J)
(if (equal (tref labyrinthe I J) 'fin)
(setq pas-trouve ())
(tset labyrinthe I J '*)
(if (and pas-trouve
0 1 2(member (tref labyrinthe I (1+ J)) '(- fin)))
(cherche-sortie I (1+ J)))
0 * * *
(if (and pas-trouve
(member (tref labyrinthe (1+ I) J) '(- fin)))
1 * $ $
(cherche-sortie (1+ I) J))
(if (and pas-trouve
(member (tref labyrinthe I (1- J)) '(- fin)))
2
* *- fin
(cherche-sortie I (1- J)))
(if (and pas-trouve
(member (tref labyrinthe (1- I) J) '(- fin)))
(cherche-sortie (1- I) J))
(ifn pas-trouve (tset labyrinthe I J 'o)) ) )
Opérations symboliques
(de cherche-sortie (I J)
(if (equal (tref labyrinthe I J) 'fin)
(setq pas-trouve ())
(tset labyrinthe I J '*)
(if (and pas-trouve
(member (tref labyrinthe I (1+ J)) '(- fin)))
(cherche-sortie I (1+ J)))
(if (and pas-trouve
(member (tref labyrinthe (1+ I) J) '(- fin)))
(cherche-sortie (1+ I) J))
(if (and pas-trouve
(member (tref labyrinthe I (1- J)) '(- fin)))
(cherche-sortie I (1- J)))
(if (and pas-trouve
(member (tref labyrinthe (1- I) J) '(- fin)))
(cherche-sortie (1- I) J))
(ifn pas-trouve (tset labyrinthe I J 'o)) ) )
Opérations symboliques
(de cherche-sortie (I J)
(if (equal (tref labyrinthe I J) 'fin)
(setq pas-trouve ())
(tset labyrinthe I J '*)
(if (and pas-trouve
0 1 2(member (tref labyrinthe I (1+ J)) '(- fin)))
(cherche-sortie I (1+ J)))
0 * * *
(if (and pas-trouve
(member (tref labyrinthe (1+ I) J) '(- fin)))
1 * $ $
(cherche-sortie (1+ I) J))
(if (and pas-trouve
(member (tref labyrinthe I (1- J)) '(- fin)))
2
* o* fin
(cherche-sortie I (1- J)))
(if (and pas-trouve
(member (tref labyrinthe (1- I) J) '(- fin)))
(cherche-sortie (1- I) J))
(ifn pas-trouve (tset labyrinthe I J 'o)) ) )
Opérations symboliques
(de cherche-sortie (I J)
(if (equal (tref labyrinthe I J) 'fin)
(setq pas-trouve ())
(tset labyrinthe I J '*)
(if (and pas-trouve
0 1 2(member (tref labyrinthe I (1+ J)) '(- fin)))
(cherche-sortie I (1+ J)))
0 * * *(if (and pas-trouve
(member (tref labyrinthe (1+ I) J) '(- fin)))
* $ $
(cherche-sortie (1+ I) J))
1 (if (and pas-trouve
(member (tref labyrinthe I (1- J)) '(- fin)))
2 o* o fin (cherche-sortie I (1- J)))
(if (and pas-trouve
(member (tref labyrinthe (1- I) J) '(- fin)))
(cherche-sortie (1- I) J))
(ifn pas-trouve (tset labyrinthe I J 'o)) ) )
Opérations symboliques
(de cherche-sortie (I J)
(if (equal (tref labyrinthe I J) 'fin)
(setq pas-trouve ())
(tset labyrinthe I J '*)
(if (and pas-trouve
0 1 2(member (tref labyrinthe I (1+ J)) '(- fin)))
(cherche-sortie I (1+ J)))
0 * * *(if (and pas-trouve
(member (tref labyrinthe (1+ I) J) '(- fin)))
1 o* $ $ (cherche-sortie (1+ I) J))
(if (and pas-trouve
(member (tref labyrinthe I (1- J)) '(- fin)))
2 o o fin (cherche-sortie I (1- J)))
(if (and pas-trouve
(member (tref labyrinthe (1- I) J) '(- fin)))
(cherche-sortie (1- I) J))
(ifn pas-trouve (tset labyrinthe I J 'o)) ) )
Opérations symboliques
(de cherche-sortie (I J)
(if (equal (tref labyrinthe I J) 'fin)
(setq pas-trouve ())
(tset labyrinthe I J '*)
(if (and pas-trouve
0 1 2(member (tref labyrinthe I (1+ J)) '(- fin)))
(cherche-sortie I (1+ J)))
0 o* * *(if (and pas-trouve
(member (tref labyrinthe (1+ I) J) '(- fin)))
1 o $ $ (cherche-sortie (1+ I) J))
(if (and pas-trouve
(member (tref labyrinthe I (1- J)) '(- fin)))
2 o o fin (cherche-sortie I (1- J)))
(if (and pas-trouve
(member (tref labyrinthe (1- I) J) '(- fin)))
(cherche-sortie (1- I) J))
(ifn pas-trouve (tset labyrinthe I J 'o)) ) )
Opérations symboliques
Résumé du module
Applications:
Typage Le Lisp : raisonnement
dynamique des un langage trés symbolique,
données puissant basé résolution de
sur les jeux, …
fonctions
Pas de distinction
Langage entre la structure de
interprété à données et celle du
syntaxe simple programme
Programmation Fonctionnelle - Le Lisp -
Publications
Eléments H. FARRENY:
d'intelligence Systèmes Expert,
artificielle de (Ed.Cepadues,
Farreny et Ghallab 1985)
(Ed. Hermes, 1987)
Fin