1 / 64

Chapitre IV

Intelligence Artificielle. Chapitre IV. Programmation fonctionnelle : Langage Lisp. EPSI / Montpellier - Cycle CSII 2A. Programmation fonctionnelle : Langage Lisp. Introduction Types de programmation

konane
Download Presentation

Chapitre IV

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Intelligence Artificielle Chapitre IV Programmation fonctionnelle : Langage Lisp EPSI / Montpellier - Cycle CSII 2A

  2. Programmation fonctionnelle : Langage Lisp • Introduction • Types de programmation • Programmation procudérale (impérative) : on donne à l ’ordinateur toutes les étapes pour résoudre le problème • Aspect séquentiel des programmes • Notions d ’affectation, de condition et de répétition • Programmation déclarative : on décrit le rapport entre les données et les résultats • Programmation logique : PROLOG • Programmation fonctionnelle: LISP

  3. Programmation fonctionnelle : Langage Lisp • Historique du langage Lisp (LISt Processing) • 1958 : Création de Lisp par John Mac Carthy • Travaux de Alonzo Church sur le lambda-calcul • Travaux de John Mac Carthy sur les fonctions récursives • 1970-1980 : Prolifération des dialectes Lisp • 1984 : Normalisation ANSI X3J13 de Lisp par Guy L. Steele • Définition du dialecte Common Lisp • 1989 : Publication officielle de la norme X3J13 • La norme Common Lisp est arrêté en Octobre 1989

  4. Programmation fonctionnelle : Langage Lisp • Caractéristique de Lisp • Un langage généralement interprété • Un langage de haut niveau • Un langage extensible • L’objet de base est la fonction • Un programme = un ensemble de définitions et d ’appels de fonctions • L ’opération de base est l ’évaluation d ’une expression • Application d ’une fonction à une liste d ’arguments • Structure de données • Les données et les programmes sont représentés par des listes

  5. Programmation fonctionnelle : Langage Lisp • Caractéristiques de Lisp • Lisp manipule des données symboliques • Donnée symbolique = s-expression • Lisp offre une approche objet de programmation • Classes et fonctions génériques • Lisp est un langage interactif • Boucle à trois temps(REPL:Read-Eval-Print Loop) Écriture du résultat (une s-expression) Lecture d ’une expression symbolique (une s-expression) Évaluation de l ’expression read print eval

  6. Programmation fonctionnelle : Langage Lisp • Caractéristiques de Lisp • Lisp est dédié au traitement symbolique : • Modélisation du raisonnement • Traitement du langage naturel • Lisp a une très grande puissance d ’expression • Idéal pour le prototypage des modèles en I.A • Pas de distinction entre donnée et programme • Code = donnée • Du code qui écrit du code • Le code est particulièrement concis

  7. Programmation fonctionnelle : Langage Lisp • Apprendre à programmer en Lisp • Maîtriser la syntaxe des s-expression • Comprendre les règles d ’évaluation • Connaître les fonctions prédéfinies • Acquérir la méthodologie et l’esprit « programmation fonctionnelle »

  8. Programmation fonctionnelle : Langage Lisp • Les dialectes de Lisp • Le_Lisp • Mac Lisp • Frantz Lisp • Koyoto Common Lisp • Scheme • etc.

  9. Programmation fonctionnelle : Langage Lisp • Le dialecte Scheme • Dialecte inventé en 1975 par Steele & Sussmann au MIT • Une reconstruction minimale de Lisp conçue à des fins pédagogiques • Scheme a été normalisé par l'IEEE puis par l'ISO en 1992 • En1997, GNU distributeur d‘Emacs choisit Scheme comme langage d'extension dans les applications [projet GUILE] • Plusieurs implémentations de Scheme sont disponibles : • DrScheme (Université de Rice à Houston, Texas, USA) : tourne sous Unix, Windows, et Macintosh • Chez Scheme (Cadence Research Systems, USA) • Scheme->C (Digital Equipment Corporation, Palo Alto, Californie, USA) • Bigloo (Inria, France)

  10. Programmation fonctionnelle : Langage Lisp • Premiers exemples • Calculer des expressions >(* 24 5) >(/ 120 6) • Afficher un message > (define (Afficher-Bonjour) Définition d ’une fonction (display "Bonjour à tous") (newline) (newline) ) > (Afficher-Bonjour) Appel d ’une fonction • Appliquer une fonction en inversant l ’ordre des arguments > (define (fonction-inverse fonction arguments) (apply fonction (reverse arguments)) ) > (fonction-inverse - '(25 40))

  11. Programmation fonctionnelle : Langage Lisp • Premiers exemples • Utiliser les fonctions anonymes (fonctions lambdas)>(define somcar (lambda(x y) (+ (* x x) (* y y)))) >((map (lambda (n) (* n n)) '(1 2 3 4 5))

  12. Programmation fonctionnelle : Langage Lisp • Syntaxe de Lisp • Syntaxe des s-expressions • s-expression • atomes • constantes :numériques (nombres) et symboliques (chaîne de caractères) • variables (identificateurs) • listes • liste vide () • listes non vides (une suite de s-expressions)

  13. Programmation fonctionnelle : Langage Lisp • Syntaxe de Lisp • Syntaxe des s-expressions • atome • nombres :exemples • entier : 123 589 • flottant : 5.6 123.48 • rationnel : 1/3 2/8 • Chaîne de caractères :exemples • Caractère : #\a #\I #\5 #\\ • Chaîne de caractères :     "EPSI" " " " x " "Cours de \"LISP\"" • Booléens : #t : vrai #f:faux

  14. Programmation fonctionnelle : Langage Lisp • Syntaxe de Lisp • Syntaxe des s-expressions • atome • Variables (identificateurs) : • une chaîne de caractères qui n ’est pas une constante et qui ne contient pas de séparateurs : ( ; ) ‘ espace • pas de distinction majuscule/minuscule • pas besoin de déclarer une variable • toute variable doit être définie à l ’aide de la fonction define • à toute variable est attribuée une valeur initiale : syntaxe : (define variable expr)exemples : • (define a 10) • (define F 15) (define G (* 4 F)) • (define-values (x y) (values 3 4))

  15. Programmation fonctionnelle : Langage Lisp • Syntaxe de Lisp • Syntaxe des s-expressions • atome • Variables (identificateurs) : • Exemples • des varibalesne sont pas des variables • y 485 • forte_fievre "votre nom ?" • *regles* (x) • <h>_os un deux trois

  16. Programmation fonctionnelle : Langage Lisp • Syntaxe de Lisp • Syntaxe des s-expressions • liste • structure formée de plusieurs s-expressions (atomes et/ou listes) • la liste vide se note () • Exemples • (Mieux vaut tard que jamais) • (4 fois 5 eqale 20) • (((ceci est) (une liste)) ( de deux elements))

  17. Programmation fonctionnelle : Langage Lisp • Syntaxe de Lisp • Exemples de s-expressions • #\A atome de type caractère constante • 100 atome de type entier • 7/8 atome de type rationnel constante • #t atome TRUE constante • #f atome FALSE constante • NULL atome NULL constante • "lisp" atome de type chaîne de caractères constante • epsi atome de type variable variable (symbole) • () liste vide • (()) liste à 1 élément • (* 5 6) liste à 3 éléments • (janvier fevrier (mars avril) juin (septembre octobre)) liste à 5 éléments • (define (carre x) (* x x)) liste à 3 éléments

  18. Programmation fonctionnelle : Langage Lisp • Evaluation des expressions • Evaluation d’un atome (constantes, variables) • Constante • valeur d’une constante = la constante elle même • Variable • valeur d’une variable = la valeur courante de la variable qui doit être définie • Exemples • > 573 • 573 • > « quel est votre nom ? » • « quel est votre nom ? » • > (define annee-courante 2002) • > annee-courante • 2002 • > mois • > erreur : reference to undefined identifier: mois

  19. Programmation fonctionnelle : Langage Lisp • Evaluation des expressions • Evaluation d’une liste (expr0 expr1 … exprn) • Evaluation en 2 étapes • étape 1 : évaluation de expr1 … exprn puis de expr0. Si vi est est le résultat de l ’évaluation de expri Alors v0 doit être une fonction • étape 2 : application de v0 aux arguments v1 … vn • une erreur survient si • v0 n ’est pas une fonction • n n ’est pas le nbre d ’arguments requis par cette fonction

  20. Programmation fonctionnelle : Langage Lisp • Evaluation des expressions • Evaluation d’une liste (expr0 expr1 … exprn) • Exemples • > (7 9 13) • erreur: 7 n ’est pas une fonction • > (remainder 13 2) • 1 • > (zero? (remainder 20 5)) • #t • >(define x 5) • > (define y 10) • > (define operateur /) • > (operateur y x) • 2

  21. Programmation fonctionnelle : Langage Lisp • Evaluation des expressions • Evaluation d’une liste (expr0 expr1 … exprn) • Exemple : évaluation de la liste(+ 3 (sqrt 2) (* 2 3 4)) • 1. • 1.1 Evaluation de 3 • 3 => 3 • 1.2 Evaluation de (sqrt 2) • 1.2.1 Evaluation de 2 • 2 => 2 • 1.2.2 • 1.3 Evaluation de (* 2 3 4) • 1.3.1 Evaluation de 2 • 2 => 2 • 1.3.2 Evaluation de 3 • 3 => 3 • 1.3.3 Evaluation de 4 • 4 => 4 • 1.3.4 2x3x4 => 24 • 2. 3 + 1.414 + 24 => 28.414 2 => 1.414

  22. Programmation fonctionnelle : Langage Lisp • Evaluation des expressions • Evaluation d’une expression quoté • Expression quoté • (quote expr) •  'expr • quote : un moyen de suspendre l ’évaluation d ’une expression • Evaluation de (quote expr) = expr • Evaluation de  ’expr = expr

  23. Programmation fonctionnelle : Langage Lisp • Evaluation des expressions • Evaluation d’une expression quoté • Exemples • > bonjour • erreur : reference to undefined identifier: bonjour • > 'bonjour • bonjour • > ( 1 2 3 4) • erreur : 1 n ’est pas une fonction • > '(1 2 3 4) • (1 2 3 4) • > (+ 5 7) • 12 • > '(+ 5 7) • (+ 5 7) • > ''(+ 5 7) • ‘ (+ 5 7) • > (quote (a b c)) • (a b c) • > '(a b c) • (a b c)

  24. Programmation fonctionnelle : Langage Lisp • Evaluation des expressions • Evaluation d’une forme spéciale • Forme spéciale : une expression dont le premier élément est un mot-clef réservé • L ’évaluation d ’une forme spéciale ne commence pas nécessairement par l ’évaluation de ces arguments • Exemple • L ’évaluation de l ’expression (define nbre 812) • provoquerait une erreur (nbre n ’est pas défini) • si define n ’était un mot clef-réservé (une fonction spéciale)

  25. . . Programmation fonctionnelle : Langage Lisp • Manipulation des listes • Représentation interne des listes • les listes sont implémentées en mémoire à l ’aide de doublets de pointeurs : • CAR : Content of Adress Register • CDR : Content of Decrement Register • Les doublets de pointeurs sont allouées dynamiquement avec une fonction spéciale appelée cons CAR CDR (car.cdr) queue Paire pointée tête

  26. Programmation fonctionnelle : Langage Lisp • Manipulation des listes • Représentation interne des listes • (a) <=> (a.()) • (2 1) <=> (2.(1.())) • (3 2 1) <=> (3.(2.(1.()))) • (a b c) <=> (a.(b.(c.())))

  27. Programmation fonctionnelle : Langage Lisp • Manipulation des listes • Fonctions de consultation • Fonction car • Syntaxe : (car liste)l ’argument évalué de car doit être une liste • Evaluation : renvoie le premier élément d ’une liste • Exemples • > (car (+ 7 11)) • car: expects argument of type <pair>; given 18 • > (car '(+ 7 11)) • + • > (car '(())) • () • > (car '(paul . pierre)) • paul • > (car '(paul pierre)) • > (car '((paul pierre) michel maurice)) • (paul pierre)

  28. Programmation fonctionnelle : Langage Lisp • Manipulation des listes • Fonctions de consultation • Fonction cdr • Syntaxe : (cdr liste)l ’argument évalué de cdr doit être une liste • Evaluation : renvoie une liste privée de son premier élément • Exemples • > (cdr (+ 7 11)) • cdr: expects argument of type <pair>; given 18 • > (cdr '(1 2 3 4)) • (2 3 4) • > (cdr '(+ 1 2)) • (1 2) • > (cdr '(a (b c))) • ((b c)) • > (car (cdr '(a (b c)))) • (b c)

  29. Programmation fonctionnelle : Langage Lisp • Manipulation des listes • Fonctions de consultation • Composition de car et de cdr • Les fonctions car et cdr sont très souvent utilisées en Lisp • Il existe des fonctions pour certaines compositions de car et de cdr • (cdr(car(cdr '(a (b c) d)))) <=> (cdadr '(a (b c) d)) • Exemples • > (cdadr '(a (b c) d)) • (c) • > (caadr '(a (b c) d)) • b • > (cdddr '(a (b c) d)) • () • > (cadar '(a (b c) d)) • erreur

  30. Programmation fonctionnelle : Langage Lisp • Manipulation des listes • Fonctions de construction • Fonction cons • Syntaxe : (cons expr1 expr2) • Evaluation : si valeur de expr1 = a et valeur de expr2 = balors valeur de (cons expr1 expr2) = (a . b) • Exemples • > (cons 'a '(b c d)) • (a b c d) • > (cons 'a  ’b) • (a . b) • >(cons 'a  ()) • (a) • > (cons '(a b)    '(c d)) • ((a b) c d) • > (cons 'a (cons 'b '(c d))) • (a b c d)

  31. Programmation fonctionnelle : Langage Lisp • Manipulation des listes • Fonctions de construction • Fonction list • Syntaxe : (list expr1 expr2 … exprn) • Evaluation : renvoie une liste dont les éléments sont les valeurs de expr1 expr2 ... Exprn(list ’a  ’b  ’c) <=> (cons ’a (cons ’b (cons ’c ()))) • Exemples • > (list 'a  ’b ’c) • (a b c) • >(list (+1 3) ’paul (car ’ (a b)) (symbol? ’paul)) • (4 paul a #t) • > (list (list ’ ())) • ((()))

  32. Programmation fonctionnelle : Langage Lisp • Manipulation des listes • Fonctions de construction • Fonction append • Syntaxe : (append liste1 liste2 … listen)Les arguments sauf le dernier qui n ’est pas une liste génère une erreur • Evaluation : concatène une série de listes • Exemples • > (append  ’(a  b) (’c ’d)) • (a b c d) • >(append ’a ’(2 3)) • erreur : append: expects argument of type <proper list>; given a • > (append ’(x y) ’z) • (x y . z)

  33. Programmation fonctionnelle : Langage Lisp • Manipulation des listes • Fonctions de traitement • Fonction length • Syntaxe : (length liste) • Evaluation : Renvoie la longueur d’une liste • Exemples • > (length  ’(a  b c)) • 3 • >(length ’()) • 0 • > (length ’(a (b) (c d e))) • 3

  34. Programmation fonctionnelle : Langage Lisp • Manipulation des listes • Fonctions de traitement • Fonction reverse • Syntaxe : (reverse liste) • Evaluation : Renvoie l’inverse d’une liste • Exemples • > (reverse  ’(a  b c)) • (c b a) • > (reverse ’(a (b) (c d e))) • ((c d e) (b) a)

  35. Programmation fonctionnelle : Langage Lisp • Variables et fonctions • Définition de variables • Forme spéciale define • Syntaxe : (define nom-variable expression) • Evaluation : Crée une variable globale nommée nom-variable et lui associe la valeur de expression • Exemples • > (define x (+ 2 3)) • > x • 5 • > (define base-de-regles ())

  36. Programmation fonctionnelle : Langage Lisp • Variables et fonctions • Affectations • Primitive set! • Syntaxe : (set! nom-variable expression) • Evaluation : Affecte à la variable nommée nom-variable la valeur de expression • Exemples • > (define a (+ 2 3)) • > (+ a 5) • 10 • > (set! a (+ a 2) • > a • 7 • > (set! a ’(b c)) • > a • (b c)

  37. Programmation fonctionnelle : Langage Lisp • Variables et fonctions • Affectations • Primitive let • Syntaxe : (let ((var1 expr1) (var2 expr2) ...) e1 e2 … en) • Evaluation : Affecte à la variable locale nommée var1 la valeur de expr1 et à la variable var2 la valeur de expr2 …, puis évalue e1 e2 .. en et renvoie la valeur de en • Exemples • > (let ((a 12) (b 5)) • (* a b)) • 60

  38. Programmation fonctionnelle : Langage Lisp • Variables et fonctions • Définition de fonctions • Forme spéciale define • Syntaxe : (define (nom arg1 arg2 … argn) expr1 expr2 … exprn)avec :nom : nom de la fonction arg1, arg2, … argn : arguments formels expr1, expr2, … exprn : corps de la fonction • Evaluation : Crée une fonction nommée nom,ayant pour arguments arg1, arg2, … argn, et pour corps les expressions expr1, expr2, … exprn • Exemple • > (define (carre x) (* x x))

  39. Programmation fonctionnelle : Langage Lisp • Variables et fonctions • Appel de fonctions • Syntaxe : (nom arg1 arg2 … argn)avec :nom : nom de la fonctionarg1, arg2, … argn : arguments effectifs • Exemples • > (carre (+ 2 3)) • 25 • > (define (trois) 3) • > (trois) • 3

  40. Programmation fonctionnelle : Langage Lisp • Variables et fonctions • Fonctions anonymes • Forme spéciale lambda • Syntaxe : (lambda (p1 p2 … pn) expr1 expr2 … exprn) • Intérêt : Définir des fonctions locales temporaires qui sont souvent utilisées avec les fonctions d’application (fonctions qui prennent une fonction en argument et qui appliquent cette fonction à d ’autres arguments) • Exemples • > (define carre • (lambda (x) (* x x))) • >((lambda (x y) (+ (* x x) (* y y))) 4 5) • 41

  41. Programmation fonctionnelle : Langage Lisp • Variables et fonctions • Fonctions d’application • Primitive apply • Syntaxe : (apply expr1 expr2)avec expr1 : une fonction F à n arguments et expr2 une liste ayant n éléments : (a1 a2 … an) • Evaluation : Renvoie la valeur retournée par la fonction F quand on l ’appelle avec les arguments a1 a2 … an • Exemples • > (apply carre ’(5)) • 25

  42. Programmation fonctionnelle : Langage Lisp • Variables et fonctions • Fonctions d’application • Primitive map • Syntaxe : (map expr0 expr1 expr2 … exprn)avec expr0 : une fonction F à n arguments et expr1 … exprn des listes ayant n éléments : (v11 v12 … v1n), (v21 v22 … v2n) … (vn1 vn2 … vnn) • Evaluation : Renvoie la liste :( F(v11 v21 … vn1) F(v12 v22 … vn2) … F(v1n v2n … vnn) ) • Exemples • > (map carre ’( 1 2 3 4 5)) • (1 4 9 16 25) • > (map * ’(2 4 8) ’(100 50 25)) • (200 200 200)

  43. Programmation fonctionnelle : Langage Lisp • Prédicats et structures de contrôle • Notion de prédicat • une fonction qui retourne la valeur « vrai » : #t ou « faux » : #f • une fonction qui est utilisée dans les structures de contrôle • Prédicats de type • (null? expr) la valeur de expr est la liste vide ? • (symbol? expr) la valeur de expr est un identificateur ? • (number? expr) la valeur de expr est un nombre ? • (string? expr) la valeur de expr est une chaîne de caractères ? • (list? expr) la valeur de expr est une liste ? • ...

  44. Programmation fonctionnelle : Langage Lisp • Prédicats et structures de contrôle • Prédicats numériques • (zero? expr) la valeur de expr est nulle ? • (even? expr) la valeur de expr est paire ? • (odd? expr) la valeur de expr est impaire ? • (= expr1 expr2) la valeur de expr1 est égale à celle de expr2 ? • (< expr1 expr2) la valeur de expr1 est inférieure à celle de expr2 ? • (<= expr1 expr2) la valeur de expr1 est inférieure ou égale à celle de expr2 ? • ...

  45. Programmation fonctionnelle : Langage Lisp • Prédicats et structures de contrôle • Prédicats d’égalité • = pour les nombres • char=? pour les caractères • string=? pour les chaînes de caractères • equal? pour les atomes et les listes • … • Exemples • > (equal? ’(a b c) ’(a b c)) • #t • > (equal? ’a ’a) • #t • > (equal? ’(a b) ’ ((a) (b))) • #f • > (equal? ’(a b) ’(a b c)) • #f

  46. Programmation fonctionnelle : Langage Lisp • Prédicats et structures de contrôle • Structures de contrôle • Structure if • Syntaxe : (if predicat expr1 expr2) • Evaluation : Renvoie la valeur de expr1 si predicat est vrai ou la valeur de expr2 sinon • Exemple • > (define x -5) • > (if (>= x 0) x (- x)) • 5

  47. Programmation fonctionnelle : Langage Lisp • Prédicats et structures de contrôle • Structures de contrôle • Structure cond • Syntaxe : (cond (predicat1 expr11 expr12 … expr1n)(predicat2 expr21 expr22 … expr2n) … (predicatn exprn1 expn2 … exprnn) (else expr1 expr2 … exprn)) • Evaluation : - Les prédicats sont évalués un à un jusqu ’à obtention d’une valeur « vrai »- Les expressions correspondants sont alors évaluées et la valeur de la dernière expression est renvoyée- Si tous les prédicats renvoient « faux », la liste d ’actions correspondants à else est exécutée • Exemple

  48. Programmation fonctionnelle : Langage Lisp • Prédicats et structures de contrôle • Structures de contrôle • Structure cond • Exemple • > (define (examiner a) • (cond ((< a 100) (display "trop petit")) • ((> a 1000) (display "trop grand")) • ((= a 0) (display "nulle")) • (else (display "rien à dire")))) • > (examiner 5) • trop petit • > (examiner 200) • rien à dire

  49. Programmation fonctionnelle : Langage Lisp • Prédicats et structures de contrôle • Opérateurs logiques • Opérateur and • Syntaxe : (and pr1 pr2 … prn) • Evaluation : - Les prédicats sont évaluées de gauche à droite- On s ’arrête dès qu ’une évaluation produit un #f- Renvoie la valeur #f ou la valeur #t

  50. Programmation fonctionnelle : Langage Lisp • Prédicats et structures de contrôle • Opérateurs logiques • Opérateur or • Syntaxe : (or pr1 pr2 … prn) • Evaluation : - Les prédicats sont évaluées de gauche à droite- On s ’arrête dès qu ’une évaluation produit la valeur #t- Renvoie la valeur #f ou la valeur #t

More Related