next up previous
Next: Àpropos de ce document...

Langages de Programmation


Plan du cours


1.
Introduction

2.
Langages fonctionnels LISP et ML (env. 5 cours + devoir)

3.
Examen partiel

4.
Langage procédural ADA (env. 5 cours + devoir)

5.
Programmation logique en PROLOG (env. 2 cours)

6.
Examen final

Évaluation


La note finale sera la somme des notes des deux devoirs et des deux examens.

                   devoir 1        :   30
                   devoir 2        :   30
                   examen partiel  :   20
                   examen final    :   20
                   ----------------------
                   Note finale     :  100

Introduction


Langages Fonctionnels


LISP


Une liste vide (notée () ou nil) est un atome et une liste à la fois!

Programmes en LISP


Quelques fonctions pré-définies


Opérations sur listes


Construction des fonctions


Fonctions de prédicats


Branchement conditionnel


Fonctions récursives


Exercice


Variables


Itération


Différents aspects d'un symbole


1.
nom symbol-name
2.
valeur symbol-value
3.
fonction symbol-function
4.
p-list (property list) symbol-plist
  • setplist symbol plist
  • get symbol property
  • put symbol property value

Autres types de données


1.
nombres: entiers , réels à virgule flottante
2.
chaînes de caractères
3.
vecteurs et tableaux
4.
A-lists (Association Lists)
  • Dotted Pair Notation (car . cdr)
  • [] eg. ((canada . ottawa) (france . paris))
  • assq key alist (ou assoc key alist )
  • rassq value alist
  • copy-alist alist

Complexité


Devoir


Recherche du chemin
le plus court (en nombre d'arcs)
dans un graph.

ML (Caml Light)


Exemple


  #3 + 5 * 4;;
  - : int = 23
  #(function x -> x + x) (3 + 4);;
  - : int = 14
  #(function x -> x + x);;
  - : int -> int = <fun>
Types


Exemple:
  #(function f -> (function (x,y) -> f (x + 1, y)));;
  - : (int * 'a -> 'b) -> int * 'a -> 'b = <fun>
Définitions locales et globales


Applications partielles


    #let f x = function y -> x + y ;;
    f : int -> int -> int = <fun>
    #let g x = f x 1;;
    g : int -> int = <fun>
    #g 3;;
    - : int = 4
    #let h = f 1;;
    h : int -> int = <fun>
    #h 3;;
    - : int = 4

Exercice:


1.
Donnez des exemples de fonctions des types suivants:
2.
Évaluez les expressions suivantes:

Types de base


N-uplets


Pattern et pattern-matching


Fonctions


Listes


Types par ``produit ''


     #type person = {Name:string; Age:int};;
     Type person defined.
     #let pierre = {Age=25; Name="Pierre"};;
     pierre : person = {Name = "Pierre"; Age = 25}
     #(function {Name=_; Age=x} -> x) pierre;;
     - : int = 25
     #pierre.Age;;
     - : int = 25
Types par ``union ''




 
next up previous
Next: Àpropos de ce document...
Wojtek Fraczak
2/9/1998