02-Programmation Fonctionnelle - Le Lisp

Programmation
Fonctionnelle
- Le Lisp -
Campus Booster ID : 513
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
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
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.
Plan du module
Voici les parties que nous allons aborder:
 Généralités, éléments de base.
 Les structures de contrôle.
 Fonctions complexes.
 Opérations symboliques.
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
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
Présentation
Historique des principaux langages, dont le Lisp.
1957 1958 1960 1964 1966 1970 1972
ALGOL LISP LOGO PROLOG
FORTRAN COBOL BASIC PL/I B PASCAL

Présentation
Historique des dialectes Lisp .
1960 1966 1967 1975 1977 1984 1985 1986
MACLISP INTERLISP LE_LISP EULISP
LISP 1.5 SCHEME VLISP CommonLISP AutoLISP

Présentation
Spécificités du langage fonctionnel Lisp
 Syntaxe simple mais parenthèses multiples
 Utilisation intensive de la récursivité
 Typage dynamique des données*
 Pas de distinction entre données et programme**
 Langage interprété***
Présentation
L’algorithme d’exécution de l’interprète est

Lecture d’une une boucle
expression
READ-EVAL-PRINT
qui s’exécute à divers niveaux de
Evaluation de profondeur en commençant par le plus
l’expression profond.
Impression du
résultat
Les expressions symboliques

Il existe trois catégories d'expressions symboliques* :
 Les atomes
 Les listes
 Les paires pointées

ATOME
Expression symbolique élémentaire.
C’est une S-EXPRESSION insécable*

La forme que peuvent prendre les atomes.
 Les noms :
 Un caractère
 ex: a
 Suite de caractères
sans séparateur
 ex: supinfo
 Les nombres :
 Nombres positifs
 Nombres négatifs

Exemples d'atomes
a
B
 ATOME
 Pierre
 Atome-Long
 unseulatomelong
 128
 -345
 *86
 49CE+
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
SÉPARATEUR
Caractère qui permet de séparer les
expressions.

La liste des séparateurs en LISP
 Le point : .
 L’espace
 Les parenthèses : ( et )
 Les crochets : [ et ]
 L’apostrophe : quote ou ’
 La tabulation
 Le point-virgule : ;
 Le retour chariot (return)
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
LISTE
S-EXPRESSION
Suite ordonnée d’atomes ou de listes

Exemples de listes
 (A B) : liste constituée de 2 atomes

 (A B C) : liste constituée de 3 atomes
 (A (B C)) : liste constituée de 1 atome et
d'une liste
 (Une liste) : liste constituée de 2 atomes
 (Jean aime Marie) : liste constituée de 3 atomes
 () : liste vide, correspond à : NIL
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)

Autres notions élémentaires
 Longueur d'une liste
 Profondeur d'une liste
 Appel d'une fonction Lisp


Notion de longueur d'une liste : ici, longueur = 3
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.

Notion de profondeur d'une liste : ici, profondeur = 2
Le premier élément Le dernier élément

(l’atome “une”) est au (l’atome “profonde”) est
premier niveau: au troisième niveau:
profondeur 0. profondeur 2
1er niveau 3ème niveau
(une (liste (profonde)))
2ème niveau
Le second élément
(l’atome “liste”) est
au second niveau:
profondeur 1.
… … )
(…
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

Appel d'une fonction
Nom de la fonction appelée Argument n°2
(nomdelafonction <arg 1> <arg 2>… <arg n>)
Argument n°1 Argument n°n

… … )
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
Fonctions arithmétiques élémentaires

Présentation des opérations arithmétiques élémentaires
 L'addition :
 (+ … …)
 La soustraction :
 (- … …)
 La multiplication :
 (* … …)
 La division :
 (/ … …)
Fonctions arithmétiques élémentaires

Exemples
FONCTIONS RESULTAT
?(+ 2 3) = 5
?(- 13 7 2) = 4
?(* 5 11) = 55
?(/ 15 3) = 5
?(+ (* 5 4) (* 2 3)) = 26
Les fonctions primitives
 QUOTE
 CAR
 CDR
 CONS
 APPEND
QUOTE
Empêche l’évaluation de l'expression
symbolique fournie en argument.
Retourne l’expression non évaluée.
Exemple:
? (quote (2 + 3))
= (2 + 3)

Appel de la fonction QUOTE
Nom de la fonction
(quote <argument>)
Argument

Exemple
FONCTION quote RESULTAT
?(quote (+ 2 3)) = (+ 2 3)
? ‘(+ 2 3 4) = (+ 2 3 4)
?(a b c) **eval: fonction indéfinie: a
?′(- 5 3) = (- 5 3)
?′(* 2 3 2) = (* 2 3 2)
?′(/ 21 7) = (/ 21 7)
?(/ 21 7) = 3
CAR
Extrait le premier élément d’une liste.
Celui-ci peut être un atome ou une liste.

Appel de la fonction CAR
Nom de la fonction
(car <argument>)
Argument
L'argument doit
être une liste

Exemple
FONCTION car RESULTAT

** eval : fonction indefinie
?(car (a b c))
: a
?(car '(a b c)) = a
** car : l'argument n'est pas

?(car (+ 2 3 4))
une liste : 9
?(car '(- 5 3)) = -
?(car '(2 3 1)) = 2
?(car '(() 21)) = () ou NIL
** eval : variable indéfinie

? car '(12 9 3)
: car
CDR
Retourne une liste privée de son
premier élément.

Appel de la fonction CDR
Nom de la fonction
(cdr <argument>)
Argument
L'argument doit
être une liste.

Exemple
FONCTION cdr RESULTAT
?(cdr '(+ 2 3)) = (2 3)
?(cdr '(14 ())) = (())
?(cdr '((2 3) 4)) = (4)
** cdr : l'argument n'est pas

?(cdr (- 5 3))
une liste : 2
?(cdr '(3 atomes seuls)) = (atomes seuls)
?(cdr '(2 (3 4))) = ((3 4))
?(cdr '(12)) = ()

Les fonctions CAR et CDR peuvent être imbriquées c’est à
dire appliquées successivement sur une liste
 (CAR (CDR <liste>))  (CADR <liste>)
 (CAR (CDR (CDR <liste> )))  (CADDR

<liste>)
 (CAR (CDR (CAR (CDR <liste>))))  (CADADR <liste>)


Appel de la fonction CADR
Nom de la fonction imbriquée
(cadr <argument>) ↔ (car (cdr <argument>))
L'argument doit
être une liste.
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
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
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

Exemples
FONCTIONS RESULTAT
?(cadr ′(a b c d)) = b
?(caddr ′(a b c d)) = c
?(cdadr ′(a (b c) d)) = (c)
?(cddr ′(a b c d)) = (c d)
?(cddar ′((a b c d) (e) f)) = (c d)
?(cadar ′((a b c) d e)) = b

CONS
Ajoute un élément en tête d’une liste

Appel de la fonction CONS
Nom de la fonction
(cons <arg 1> <arg 2>)
Arguments
Le nombre
d'arguments est fixe
et égal à deux.

Exemple
FONCTION cons RESULTAT
?(cons ‘a '(b c)) = (a b c)
?(cons '(a b) '(c d)) = ((a b) c d)
**cons : mauvais nombre

?(cons '(a b c))
d'arguments : 2
?(cons ‘a ‘b) = (a.b)
?(cons ‘a ()) = (a)
**eval : fonction indefinie :

?(cons '(a b) (12))
12
?(cons ‘a (+ 20 (* 12 30))) = (a.380)

APPEND
Permet de concaténer les listes
transmises en argument.

Appel de la fonction APPEND
Nom de la fonction
(append <arg 1> <arg 2> <arg n>)
Arguments

Exemple
FONCTION append RESULTAT
?(append '(a b) '(c d)) = (a b c d)
?(append '(a) '(b c)) = (a b c)
?(append () '(a b c)) = (a b c)
?(append '(a b) ()) = (a b)
?(append '(a) '380) = (a . 380)
?(append ‘a '(380)) = (380)
?(append '(a) '(380)) = (a 380)

Les prédicats
Quelques prédicats usuels:
 ATOM
 CONSP
 NULL
 EQUAL
 NUMBERP
 < ou > ou <= ou >=
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.
Les prédicats
Appel de la fonction ATOM
Nom de la fonction
(atom <argument>)
Argument
Les prédicats
CONSP
Teste si l'expression est une liste.
Retourne l'expression si le test est
vérifié, ( ) dans le cas contraire.
Les prédicats
Appel de la fonction CONSP
Nom de la fonction
(consp <argument>)
Argument
Les prédicats
NULL
Teste si l'expression est égale à ( ).
Retourne t (vrai) si le test est vérifié, ( )
dans le cas contraire.
Les prédicats
Appel de la fonction NULL
Nom de la fonction
(null <argument>)
Argument
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.
Les prédicats
Appel de la fonction EQUAL
Nom de la fonction
(equal <arg1> <arg2>)
Argument
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.
Les prédicats
Appel de la fonction NUMBERP
Nom de la fonction
(numberp <argument>)
Argument
Les prédicats
< ou > ou <= ou >=

Compare les arguments transmis, par
rapport aux critères d'infériorité ou de
supériorité.
Retourne le premier argument si le
critère est vérifié, ( ) (ou NIL) dans le
cas contraire.
Les prédicats
Appel des fonctions <, >, <=, >=
Nom de la fonction
(< <arg1> <arg2>... <arg n>)
Arguments
Les prédicats
Exemples
FONCTION RESULTAT
?(atom ‘pierre) = t
?(consp '(une liste)) = (une liste)
?(null ()) = t
?(equal‘(a b)‘(a (b))) = ()
?(equal '(a (b)) '(a (b))) = t
?(numberp ‘a) = ()
?(numberp 216) = 216

Fonctions d'affectation et d'évaluation
 SETQ
 LET
SETQ
Affecte aux symboles la valeur de
l'évaluation des expressions.
Les symboles conservent la valeur des
expressions après l'appel.

Appel de la fonction SETQ
Nom de la fonction
(setq <symbole1> <valeur1>... <symbole n> <valeur n>)
Arguments

Exemples (ATTENTION, exercices chaînés)
FONCTION setq RESULTAT
?(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
LET
Retourne la valeur d’une fonction dont
les variables ont des valeurs locales à
LET.
Exemple : ( let ( (a 2) (b 3) ) (+ a b) ) = 5

Forme générale de la fonction LET
Nom de la fonction
interne à LET
(let (<symb1 val1>… <symb n val n>) fonction)
Liste des paires variable-valeur


Exemple (ATTENTION, exercices chaînés)
FONCTION let RESULTAT
? a = 13
? b = 27
?(let ((a 5) (b 8)) (* a b)) = 40
? a = 13
? b = 27
?(let((a (+ 2 3)) (b (+ 4 6))) (* a b)) = 50

Représentation graphique des listes

MODELISATION des ARBRES : Rappel
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

MODELISATION d'une liste à 1 niveau : (A B)
 Profondeur 0 :
 ()
 Profondeur 1 :
 A
 B
A B

MODELISATION d'une liste à 2 niveaux : ( ( 1 2 3 ) B )
 Profondeur 0 :
 ()
 Profondeur 1 :
 ()
 B
( ) B
 Profondeur 2 :
 1
1 2 3
 2
 3

MODELISATION d'une liste à 2 niveaux : ((A B) (C D) (E F))
 Profondeur 1 :
 ()
 ()
 ()
 Profondeur 2 :
 A
 B
 C A B C D E F
 D
 E
 F

MODELISATION d'une liste complexe :
((( A )( B )( C )) G ((((( D E )) F ) H )))
 Profondeur 1 : G 0
 Profondeur 3 :
1 G
 A
 B 2
 C
3 A B C H
 H
4 F
 Profondeur 4 : F
 Profondeur 6 : 5
 D
6 D E
 E
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

Méthode de modélisation d'une liste complexe :
((( A )( B )( C )) G ((((( D E )) F ) H )))
 -1-: 0
 Lecture de la liste de
gauche à droite 1 G
 Avant la première
parenthèse, indicer 2
par le chiffre zéro : 0(
 -2-: 3 A B C H
 À 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

Méthode pour modéliser une liste complexe : (réponse)
( ( ( A 3)2(3 B 3)2(3 C 3)2)1 G 1(2(3(4(5(6 D E 6)5)4 F 4)3 H 3)2)1)0
0 1 2 3
 Contrôle :
0
 On doit retrouver le
zéro en fin de ligne,
sinon : 1 G
 erreur de
parenthésage 2
 (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

1 Liste initiale : (A (B C) D E)
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))
La fonction CDR a extrait le reste de

5 A ( (B C) D E)
la liste en une liste.
(B C) est le second élément de la liste
6
initiale. 4 5
8
D est le troisième élément de la liste 6
7
initiale. 7
E est le quatrième élément de la liste
8
initiale.

Arbre complet de la liste (A (B C) D E)
(A (B C) D E)
A ((B C) D E)
(B C) (D E)
B (C) D (E)
C NIL E NIL
Les fonctions d'entrée/sortie
 READ
 PRINT
 PRINCH
 TERPRI
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.

Appel de la fonction READ
Nom de la fonction
(read)
Aucun argument
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).

Appel de la fonction PRINT
Nom de la fonction
(print <arg1> <arg n>)
Arguments
PRINCH
Edite un certain nombre de fois le
caractère transmis à la fonction.

Appel de la fonction PRINCH
Nom de la fonction
(princh <caractere> <nombre>)
Caractère Nombre de répétitions

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.

Appel de la fonction TERPRI
Nom de la fonction
(terpri <nombre>)
Argument

FONCTIONS RESULTAT
?(setq a (read)) ?
?le_lisp = le_lisp
? a = le_lisp
?(print "lisp") lisp
?(print) = () après un saut de ligne
?(princh '-' 12) ------------= -
?(terpri 2) = t après 2 sauts de ligne

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
Pause-réflexion sur cette 1ère partie
Avez-vous des questions ?

Les structures de contrôle

Plan de la partie
 Les opérations de sélection

 La récursivité
 Fonctions récursives sur les
ensembles
 L’itération
Les opérations de sélection
 IF (sélectionne une réponse suite à une condition)
 COND (composée de plusieurs IF emboîtés)


Appel de la fonction IF
Nom de la fonction Action pour condition vraie
(if (condition) (alors_action1) (sinon_action2)….

…(sinon_action n))
Condition
à évaluer Actions pour condition fausse

Structure de la fonction COND
(cond
vrai
((test1) --------------------->(action1))
faux vrai
((test 2) --------------------->(action2))
faux
.
. vrai
( T -------------------->(actions par défaut)))

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)))
La récursivité
La récursivité
 Concept fondamental :
 en mathématique :
 relation de récurrence
 en informatique :
 procédures récursives
La récursivité
Le principe de la récursivité en algorithmique
 Fonction qui s’appelle elle-même
 Appels de plus en plus « simples »
 Solution directe pour le dernier appel
 Respect de la condition d’arrêt

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)) ) )
)
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
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) ) )
)
)
FONCTION member RESULTAT
?(member 'a '(b d a f g)) = (a f g)
?(member '3 '(2 5 9)) = ()

Fonctions récursives sur les ensembles

Autres exemples de fonctions récursives :
 ENSEMBLE : teste si une liste est un ensemble (pas de doublons)
(defun ensemble (liste)
(cond
((null liste) t)
((member (car liste) (cdr liste)) ())
(t (ensemble (cdr liste) ) )
)
)
FONCTION ensemble RESULTAT
?(ensemble '(a b c d e f g)) = t
?(ensemble '(1 2 (1 2 3) 2 (3 4))) = ()


 INCLUS : teste si tous les éléments d'une liste se trouvent
dans une autre
(defun inclus (liste1 liste2)
(cond
((null liste1) t)
((member (car liste1) liste2)
(inclus (cdr liste1) liste2))
(t ())
)
)
FONCTION inclus RESULTAT
?(inclus '(a b c) '(a c f b g)) = t
?(inclus '(a b c) '(a c f g)) = ()
?(inclus '(a b c) '(a c f b g a)) = ()


 COMPARE : teste l'égalité de deux ensembles
?(defun compare (liste1 liste2)

(if
(inclus liste1 liste2)
(inclus liste2 liste1)
)
)
FONCTION compare RESULTAT
?(compare '(1 2 3) '(3 1 2)) = t
?(compare '(1 2 3) '(1 2 4)) = ()
?(compare '(a) 'a) = ()


 UNIQUE : transforme une liste en un ensemble (sans doublons)

?(defun unique (liste)
(cond
((null liste) ())
((member (car liste) (cdr liste))
(unique (cdr liste)))
(t (cons (car liste) (unique (cdr liste))))
)
)
FONCTION unique RESULTAT
?(unique '(a b c a b d e)) = (c a b d e)
?(unique '(1 3 4 9)) = (1 3 4 9)
?(unique '(a b c a c)) = (b a c)


 UNION : créé un ensemble constitué des éléments de 2 listes
?(defun union (liste1 liste2)

(unique (append liste1 liste2))
)
FONCTION union RESULTAT
?(union '(1 3 5) '(1 3 7)) = (5 1 3 7)
?(union '(a b) '(c d e)) = (a b c d e)
?(union '(1 3 5) '(6 3 1)) = (5 6 3 1)


 INTER : créé un ensemble constitué des éléments communs

?(defun inter (liste1 liste2)
(cond
((null liste1) ())
((member (car liste1) liste2)
(cons (car liste1) (inter (cdr liste1) liste2)))
(t (inter (cdr liste1) liste2))
)
)
FONCTION inter RESULTAT
?(inter '(1 2 3) '(4 5 6)) = ()
?(inter '(a b c) '(d e f a)) = (a)
?(inter '(a b c) '(a e i c o)) = (a c)

L’itération
Fonctions itératives:
 PROG..GO..RETURN
 WHILE
Syntaxe de PROG:
(prog <liste> <S-expression1>…..<S-expression n>)
Syntaxe de GO: (go <atom>)
Syntaxe de RETURN: (return <S-expression>)

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)
)
)
)
FONCTION puissance RESULTAT
?(puissance 3 2) = 9
L’itération
Exemple 2: dernier élément d’une liste
?(defun dernier (liste)

(prog ()
encore
(cond
((null (cdr liste)) (return (car liste)))
(t (setq liste (cdr liste)))
)
(go encore)
)
)
FONCTION dernier RESULTAT
?(dernier '(a b c d)) = d

L’itération
Exemple 3: inversion d’une liste
?(defun reverse (liste)

(prog (x)
(setq x ())
hello
(cond
((null liste) (return x))
((atom liste) (return (cons liste ())))
(t (setq x (cons (car liste) x) liste(cdr liste)))
)
(go hello)
)
)
FONCTION reverse RESULTAT
?(reverse '(a b c d) = (d c b a)
L’itération
Exemple 4: la variante itérative de la factorielle
?(defun factorielle (n)

(prog (resultat)
(setq resultat 1)
toujours
(cond
((= 0 n) (return resultat))
)
(setq resultat (* resultat n) n (- n 1))
(go toujours)
)
)
FONCTION factorielle RESULTAT
?(factorielle '(3)) = 6
L’itération
Syntaxe de WHILE
(WHILE (condition)
(S-expression1)
(S-expression2)
………………….
(S-expression n)
)
WHILE évalue les S-expressions TANT QUE la

condition retourne VRAI
L’itération
Exemple: affichage du décompte d’un nombre n
?(defun decompte (n)

(while (> n 0)
(print n)
(decr n)
)
)
FONCTION decompte RESULTAT

?(decompte 4) 4
3
2
1
= ()
Pause-réflexion sur cette 2ème partie

Fonctions complexes
Fonctions complexes
Plan de la partie
 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
 (APPLY < f > < liste >)

 retourne la valeur de l'application de la fonction < f >
sur la liste < liste >
FONCTION apply RESULTAT
?(apply '+ '(2 3 4)) = 9
?(apply 'append '((a b) (c d))) = (a b c d)
?(apply '/ '(6 2)) = 3
?(apply 'modulo '(6 2)) = 0

Fonctions complexes
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.
(defun mapcar (fonction liste)

(if (null liste)
()
(cons (apply fonction (list (car liste)))
(mapcar fonction (cdr liste))
)
)
)
FONCTION mapcar RESULTAT
?(mapcar '1+ '(1 2 3 4 5)) = (2 3 4 5 6)

Fonctions complexes
Les fonctions anonymes

(LAMBDA <paramètres> <corps de la fonction> <valeurs locales>)
 La fonction anonyme LAMBDA retourne l’évaluation d’

une <fonction> avec des <paramètres> qui prennent des
<valeurs locales>. En dehors de LAMBDA les paramètres
sont déliés.
FONCTION lambda RESULTAT
?((lambda (x y) (* x y)) 2 3) = 6
?((lambda (x y) (cons y x)) 'a 'b) = (b . a)
?(setq a '(lambda (x y) (* x y))) = (lambda (x y)

(* x y))
?(apply a '(2 3)) = 6
?(mapcar (lambda (x) (* x x x)

= (8 27 64 125)
'(2 3 4 5))
Fonctions complexes
Les macro fonctions

 Une macro est évaluée en deux étapes. La première
correspond à une phase d'expansion (ou de traduction) en
une forme évaluable en LISP. Dans la deuxième étape cette
forme est évaluée.
 Voici un exemple qui transforme la structure IF en une macro.
(dmd if(test vrai faux)
(list 'cond
(list test vrai)
(list 't faux)
)
)
FONCTION RESULTAT
?(if (< a 0) (1- a) (1+ a)) = (cond
((< a 0) (1- a))
(t (1+ a))
)
Fonctions complexes
Les macro fonctions
 Le caractère "backquote" ou ` : construit une liste sans

évaluer ses éléments. L'effet du "backquote" est annulé
grâce à la "virgule" ou à l'association « virgule-arobas ».
FONCTION RESULTAT
?`(a b c d) = (a b c d)
?(setq a `(toto riri)) = (toto riri)
? `( a b ,a a) = (a b (toto riri) a)
? `(a b ,@a a) = (a b toto riri a)

Fonctions complexes
Les macro fonctions

Les macro fonctions EMPILE et DEPILE
(dmd empile (liste var)
`(setq ,liste (cons ,var ,liste))
)
(dmd depile (liste)
`(let ((res (car ,liste)))
(setq ,liste (cdr ,liste))
)
)
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
Les macro fonctions

Les macro caractères
 Caractères spéciaux auxquels sont associées des fonctions.

 Fonctionnent en deux temps comme les macro fonctions:
- Génération de code LISP
- Exécution
FONCTION dmc RESULTAT
?(dmc |$| () '1euro) = $
? '($ $) = (1euro 1euro)
(dmc |$| () (eval (read))) = $

'(1 2 3 $ (+ 2 3) 6) = (1 2 3 5 6)
Fonctions complexes, opérations symboliques

Programmation fonctionnelle - Le Lisp -
Opérations symboliques
Plan de la partie
 Dérivation des expressions algébriques

 Exploration des arborescences
 Explorer un espace d’états
 Raisonnement symbolique
Dérivation des expressions algébriques
 La dérivation d'expressions algébriques sera illustrée

dans le cas des expressions ne contenant que des
additions et des multiplications*.
 Le programme de dérivation est complété par des

programmes de simplification**:
- SIMPLIF_PLUS pour l'addition et SIMPLIF_MULT
pour la multiplication.
-"SIMPLIF" pour simplifier les parenthèses intérieures.
- SIMPLIFIER, va en profondeur avec SIMPLIF
jusqu'à ce que l'on arrive à une forme irréductible.

Fonction : DERIV
(defun deriv (exp var)
(cond ((numberp exp) 0)
((atom exp) (if (equal exp var) 1 0))
((equal (car exp) '+) (list '+
(deriv (cadr exp) var) (deriv (caddr exp) var)))
((equal (car exp) '*) (list '+
(list '* (cadr exp) (deriv (caddr exp) var))
(list '* (deriv (cadr exp) var) (caddr exp))))
(t 'bof)
)
)
FONCTION deriv RESULTAT

(deriv '(+ x 3) 'x) = (+ 1 0)
(deriv '(* x(* x x)) 'x) = (+(* x(+(* x 1)(* 1

x)))(* 1(* x x)))

Fonction : SIMPLIF
(defun simplif (exp)

(cond ((null exp) ())
((atom exp) exp)
((equal (car exp) '+)
(simplif_plus (car exp) (cadr exp) (caddr exp)))
((equal (car exp) '*)
(simplif_mult (car exp) (cadr exp) (caddr exp)))
(t 'ouf)
)
)
FONCTION simplif RESULTAT

(simplif '(+ (* x 0) (* y 0))) = (+ 0 0)

Fonction : SIMPLIF_PLUS et SIMPLIF_MULT
(defun simplif_plus (op A1 A2)

(cond
((equal A1 0) (simplif A2))
(t (list op (simplif A1) (simplif A2)))
)
)
(defun simplif_mult (op A1 A2)

(cond
((or (equal A1 0) (equal A2 0)) 0)
(t (list op (simplif A1) (simplif A2)))
)
)

Fonction : SIMPLIFIER
 SIMPLIFIER : applique récursivement le processus de
simplification jusqu'à l'obtention d'une expression
irréductible.
(defun simplifier (exp)

(let ((dexp (simplif exp)))
(if (equal exp dexp) exp (simplifier dexp))
)
)
(defun deriver (exp var) (simplifier (deriv exp var)))
FONCTION simplifier et deriver RESULTAT

(simplifier '(+ (* x 0) (* y 0))) = 0
(deriver '(* x (* x 2)) 'x) = (+ (* x 2) (* x 2))

Exploration des arborescences
 L'exploration des structures arborescentes est une

technique dont la maîtrise est essentielle en
programmation symbolique.
 Les arbres (ou arborescences : arbres avec relation

d'incidence), sont utiles pour représenter un ensemble
d'éléments hiérarchisés*.
 L'exploration d'un arbre peut se faire en profondeur ou en

largeur. Dans le cas d'une exploration en profondeur, il
existe trois types de parcours : préordre, inordre et
postordre**.

Soit l'expression : (4 * 3) + (5 * 2)
et sa représentation graphique sous forme d’arbre.
+
* *
4 3 5 2
Exploration en profondeur Liste d'exploration
En inordre:fils gauche, noeud,
4 * 3 + 5 * 2
autres fils
En préordre:un noeud puis les
+ * 4 3 * 5 2
autres fils
En postordre:les fils d’abord, les
4 3 * 5 2 * +
noeuds ensuite
Exploration en largeur Liste d'exploration

Largeur :on examine les noeuds du
+ * * 4 3 5 2
même niveau

Représentation en Le_LISP de l’arbre ci-dessous
+
* *
4 3 5 2
(setq arbre
'(+
(*
(4)
(3)
)
(*
(5)
(2)
)
)
)

Exploration en préordre de l’arbre ci-dessous
+
* *
4 3 5 2
(defun preordre (fonction arbre)
(when arbre
(apply fonction (list (car arbre)))
(preordre fonction (cadr arbre))
(preordre fonction (caddr arbre))
)
)

? (preordre ‘prin arbre) + * 4 3 * 5 2

Exploration en INORDRE de l’arbre ci-dessous:
+
* *
4 3 5 2
(defun inordre (fonction arbre)
(when arbre
(inordre fonction (cadr arbre))
(inordre fonction (caddr arbre))
)
)

? (inordre ‘prin arbre) 4 * 3 + 5 * 2

Exploration en POSTORDRE de l’arbre ci-dessous
+
* *
4 3 5 2
(defun postordre (fonction arbre)
(when arbre
(postordre fonction (cadr arbre))
(postordre fonction (caddr arbre))
)
)

? (postordre ‘prin arbre): 4 3 * 5 2 * +

LARGEUR sur l'expression : (4 * 3) + (5 * 2)
+
* *
4 3 5 2
(defun largeur (fonction arbre)
(let ((file (list arbre)))
(while file
(setq file (append file (cdar file)))
(apply fonction (list (caar file)))
(depile file) ) ) )
(dmd depile (l)
`(let ((res (car l))) (setq ,l (cdr ,l)) res ) )
Exploration en largeur Liste d'exploration

? (largeur ‘prin arbre) + * * 4 3 5 2

Exemple d’arborescence: une classification hiérarchique
(setq arbre
'(chose
(etre_vivant
(plante
(arbre
(pin)
(chene) )
(fleur) )
(animal
(insecte)
(reptile)
(mammifere
(chien)
(singe)
(etre_humain) ) ) )
(inanime
(naturelle
(nuage)
(roche)
(artificielle
(voiture)
(maison)
(ordinateur) ) ) ) )
chose
etre_vivant inanimé
plante animale naturelle artificielle
arbre fleur insecte reptile mammifère nuage roche voiture maison ordinateur
pin chene chien singe etre_humain

Explorer un espace d’états
 Un espace d’états est une représentation codée d’un

problème réel.
 Trouver la solution du problème consiste à trouver le
chemin qui relie l'état initial à l'état final (le but).
 Le passage d'un état à l'autre se fait par l'application
d'opérateurs spécifiques à chaque type de problème.
 Dans le cas présent le problème consiste à trouver la
sortie d'un labyrinthe représenté sous la forme d'un
tableau de symboles.
 Le programme doit permettre de marquer le chemin
parcouru, de sortir des cul-de-sac et de marquer le
chemin correct.

 Voici le labyrinthe sur lequel nous allons dérouler le
programme
 Le tableau comporte seulement 9 cases afin de faciliter la
compréhension de l’algorithme de recherche de la
sortie.Le programme complet sera donné en TP
 L'entrée se trouve à la case (0,0)
 La sortie est marquée par l’atome "fin".
J:0 1 2
I:
0 - - -
1 - $ $
2 - - fin

Exemple, Le Labyrinthe : I = 0, J = 0
(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)) ) )

(if (and pas-trouve
0 * *- -(if (and pas-trouve
1 - $ $
(if (and pas-trouve
2 - - fin
(if (and pas-trouve

(if (and pas-trouve
0 * * *-(if (and pas-trouve
1 - $ $
(if (and pas-trouve
2 - - fin
(if (and pas-trouve

(if (and pas-trouve
(member (tref labyrinthe I (1+ J)) '(- fin)))
(if (and pas-trouve
(if (and pas-trouve
(if (and pas-trouve

(if (and pas-trouve
(if (and pas-trouve
(if (and pas-trouve
(if (and pas-trouve

(if (and pas-trouve
0 * * * (if (and pas-trouve
*- $ $
1 (if (and pas-trouve
2 - - fin
(if (and pas-trouve

(if (and pas-trouve
0 * * * (if (and pas-trouve
* $ $
2
*- - fin (cherche-sortie I (1- J)))
(if (and pas-trouve

(if (and pas-trouve
0 * * *
(if (and pas-trouve
1 * $ $
(if (and pas-trouve
2
* *- fin
(if (and pas-trouve

(if (and pas-trouve
(if (and pas-trouve
(if (and pas-trouve
(if (and pas-trouve

(if (and pas-trouve
0 * * *
(if (and pas-trouve
1 * $ $
(if (and pas-trouve
2
* o* fin
(if (and pas-trouve

(if (and pas-trouve
0 * * *(if (and pas-trouve
* $ $
2 o* o fin (cherche-sortie I (1- J)))
(if (and pas-trouve

(if (and pas-trouve
0 * * *(if (and pas-trouve
1 o* $ $ (cherche-sortie (1+ I) J))
(if (and pas-trouve
2 o o fin (cherche-sortie I (1- J)))
(if (and pas-trouve

(if (and pas-trouve
0 o* * *(if (and pas-trouve
1 o $ $ (cherche-sortie (1+ I) J))
(if (and pas-trouve
2 o o fin (cherche-sortie I (1- J)))
(if (and pas-trouve

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
Pour aller plus loin…

Si vous voulez approfondir vos connaissances:
Publications
Eléments H. FARRENY:
d'intelligence Systèmes Expert,
artificielle de (Ed.Cepadues,
Farreny et Ghallab 1985)
(Ed. Hermes, 1987)
Intelligence 512 problèmes

artificielle et corrigés en Pascal,
informatique C++, Lisp, Prolog
théorique (2e ed.)
Louis Gacôgne
(Broché) de J.-M.
Alliot, T. Schiex, (Ed.Ellipses, 1996))
P. Brisset
Félicitations
Vous avez suivi avec succès le
module de cours n°3
Programmation Fonctionnelle -
Le Lisp -
Fin
 Examinez à nouveau les principales primitives de ce langage,

son fonctionnement récursif omniprésent et les principales
approches de résolution abordées durant ce cours.

02-Programmation Fonctionnelle - Le Lisp

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

02-Programmation Fonctionnelle - Le Lisp

Transféré par

Droits d'auteur :

Formats disponibles

Programmation

Campus Booster ID : 513

 Généralités, éléments de base.

 Les structures de contrôle.

1957 1958 1960 1964 1966 1970 1972

ALGOL LISP LOGO PROLOG

FORTRAN COBOL BASIC PL/I B PASCAL

1960 1966 1967 1975 1977 1984 1985 1986

MACLISP INTERLISP LE_LISP EULISP

LISP 1.5 SCHEME VLISP CommonLISP AutoLISP

 Utilisation intensive de la récursivité

 Typage dynamique des données*

 Pas de distinction entre données et programme**

L’algorithme d’exécution de l’interprète est

Les expressions symboliques

 Les paires pointées

Les expressions symboliques

Les expressions symboliques

Les expressions symboliques

Les expressions symboliques

Les expressions symboliques

Les expressions symboliques

Les expressions symboliques

Les expressions symboliques

Les expressions symboliques

 (A B) : liste constituée de 2 atomes

Les expressions symboliques

Les expressions symboliques

 Longueur d'une liste

 Profondeur d'une liste

 Appel d'une fonction Lisp

Les expressions symboliques

Les expressions symboliques

Le premier élément Le dernier élément

(une (liste (profonde)))

Les expressions symboliques

Les expressions symboliques

Nom de la fonction appelée Argument n°2

(nomdelafonction <arg 1> <arg 2>… <arg n>)

Argument n°1 Argument n°n

Les expressions symboliques

Fonctions arithmétiques élémentaires

Fonctions arithmétiques élémentaires

Les fonctions primitives

Les fonctions primitives

Les fonctions primitives

Les fonctions primitives

FONCTION quote RESULTAT

?(a b c) **eval: fonction indéfinie: a

Les fonctions primitives

Les fonctions primitives

Les fonctions primitives

FONCTION car RESULTAT

?(car '(a b c)) = a

** car : l'argument n'est pas

?(car '(- 5 3)) = -

?(car '(2 3 1)) = 2

?(car '(() 21)) = () ou NIL

** eval : variable indéfinie

Les fonctions primitives

Les fonctions primitives

Les fonctions primitives

FONCTION cdr RESULTAT

?(cdr '(+ 2 3)) = (2 3)