1 Spécifications de Problèmes. 2 Plan Définition Motivation Qualités attendues Types de formalismes Rappels du cours de programmation Spécifications structurées.

Présentation au sujet: "1 Spécifications de Problèmes. 2 Plan Définition Motivation Qualités attendues Types de formalismes Rappels du cours de programmation Spécifications structurées."— Transcription de la présentation:

1 1 Spécifications de Problèmes

2 2 Plan Définition Motivation Qualités attendues Types de formalismes Rappels du cours de programmation Spécifications structurées –Exemple –Niveaux d'abstraction

3 3 COMMENT procedure CalculerMax(t,max) max=t[1]; For i:=1 to Length(t) do if t[i]>max then max:=t[i] QUOI - On reçoit un tableau d'entiers t - On calcule max - A la fin de l'exécution du programme, max est aussi grand que tous les élément du tableau t Spécification: Définition Petit Larousse: "Spécifier quelque chose, c'est le déterminer, l'exprimer de manière précise" Spécification = description d'un problème (informatique) à résoudre ou résolu Dire QUOI (le problème) sans dire COMMENT (une solution) –Solution = algorithme dans un langage de programmation –Problème = indépendant de la façon de le résoudre et du langage de programmation Exemple: CalculerMax(t,max):

4 4 Spécification: Motivation Une spécification permet de –Décrire ce que fait un programme existant de manière plus abstraite pour le comprendre ou l'expliquer le refaire ou le changer –Imaginer plusieurs solutions à un problème –Communiquer le problème à quelqu'un qui va le résoudre –Dériver méthodiquement une solution (par invariant) –Vérifier (voir prouver) que la solution résoud le problème –...

5 5 Spécification: Qualités Attendues Précise, non-ambiguë –que veut dire aussi grand ? = ou > ou >= ? Complète –quid si t est vide? Minimale (pas d'info superflue) –pas de redondance –pas d'éléments de solution Cohérente (pas de contradictions) Claire et compréhensible –simple –structurée QUOI - On reçoit un tableau d'entiers t - On calcule max - A la fin de l'exécution du programme, max est aussi grand que tous les élément du tableau t Qualités parfois complémentaires ou contradictoires !

6 6 Types de Formalismes Descriptions informelles, en langue naturelle (texte) Descriptions graphiques –symboles, arcs Descriptions formelles –concepts (variables, types, assertions,…) –base mathématique ou logique interprétation des assertions QUOI - On reçoit un tableau d'entiers t - On calcule max - A la fin de l'exécution du programme, max est aussi grand que tous les élément du tableau t max: Integer t: Array[Integer] Pré: Length(t) > 0 Post: EXISTS i: a[i] = max AND FORALL j<>i: a[j] <= max CalculMax tableau max

7 7 Types de Formalismes: Comparaison L angue naturelle (texte)  ambiguïté, incohérence, incomplétude possible intuitif => compréhensibles Descriptions graphiques  ambiguïté intuitive => compréhensible, structurée Descriptions formelles  syntaxe difficile => moins intuitif précision, vérification de cohérence, complétude, preuve

8 Types de formalismes: Conclusion Pas de panacée Utiliser la plus appropriée en fonction du moment Utiliser une combinaison des styles –Graphique + texte –Assertions + texte,… Avant d'écrire le programme, on devrait avoir une description (quasi-)formelle.

9 9 Rappels: Spécifications Précises - Cours de B. Le Charlier Spécifier des fonctions –objets utilisés = "variables globales" nom et type peuvent être modifiés –paramètres en entrée, résultats nom et type –précondition assertions doivent être vraies avant l'exécution pour que la fonctionnalité produise correctement ses effets –postcondition assertions qui sont établies par la fonctionnalité si la précondition était vérifiée

10 Rappels: Spécifications Précises - Cours de B. Le Charlier Spécifier des types logiques (données) –pas de représentation explicite des données (pointeurs, tableaux,...) –lors de l'implémentation, on fait des choix de représentation Spécifier des types logiques (données), 2 approches: –valeur: ensemble de valeurs immuables + opérations type abstrait: axiomes "haut niveau": effet opération sur une valeur folklore: référence à un objet connu (file, pile, séquence,…) –objet: structure de données logique opérations de création, modification, destruction invariants globaux opérations: pré/post

11 11 Exemple: le simulateur de livreur Un livreur doit charger des marchandises dans un camion. Les marchandises ayant chacune un poids connu, sont divisées en lots. Le livreur charge un nouveau lot dans le camion en veillant à ne pas dépasser la charge maximum du camion. S'il est incapable de charger le dernier lot, il essaye de le décomposer en deux lots de façon à pouvoir remplir au maximum le camion. S' il ne peut plus remplir le camion, le livreur délivre toutes les marchandises (vide le camion) puis recommence son travail avec le lot resté en suspend et les lots arrivés ensuite. Lots Livreur

12 Conceptualisation du problème

13 Diagramme de Contexte Production Simulateur Livreur ArrivéeLot(lot) TraiterLot Livrer Lots à Traiter Charge Camion Charge Max

14 14 Identification des Fonctions Principales Arrivée Lot Lot TraiterLot Charge Camion Livrer Charge Max Lots à traiter Charge Camion Lots à traiter Charge Camion Lots à traiter

15 Types de données Lot : LOT LOT = SEQ[Integer] Lots à traiter : FILE[LOT] Charge Camion: Integer Charge Max: Integer

16 16 Spécification Arrivée Lot Pré/Post Arrivée d'un lot supplémentaire qui est ajouté à la file des lots à traiter par le livreur. Paramètre en entrée: Lot : LOT LOT=SEQ[Integer] Objects Utilisés: Lots à traiter : FILE[LOT] Précondition: Le lot qui arrive n'est pas vide Lot <> [] Postcondition: Le lot qui arrive est ajouté à la tête de la file des lots Lots à traiter = Ajout(Lots à traiter 0, Lot) Hypothèse: la spécification de la fonction d'ajout dans une file est connue ( voir cours de programmation, Baudouin Le Charlier)

17 17 Spécification Livrer Pré/Post Livraison du contenu du camion. Paramètre en entrée: / Objects Utilisés: Charge Camion: Integer Précondition: On ne peut pas livrer un camion vide Charge Camion <> 0 Postcondition: Le camion est complètement livré Charge Camion = 0

18 18 Spécification Traiter Lot Pré/Post (1) Traitement du premier lot de la file des lots à traiter. Objects Utilisés: Lots à traiter : FILE[LOT] Charge Max: Integer Charge Camion: Integer Variables intermédiaires: Lot traité: LOT Lot à charger: LOT Lot à laisser: LOT l: FILE[LOT] Précondition: Charge Max>=Charge camion Lots à traiter <> []

19 Spécification Traiter Lot Pré/Post (2) Postcondition: SI (PoidsTotal(First(Lots à Traiter)<=Charge Max 0 - Charge camion 0 ) ALORS: On peut charger le premier lot complétement: (Lots à traiter, Lot traité) = Retrait(Lots à traiter 0 ) ET Charge camion = Charge camion 0 + PoidsTotal(Lot traité) SINON: Il faut décomposer le premier lot : (l, Lot traité) = Retrait(Lots à traiter 0 ) ET Lots à traiter = Ajout(l,Lot à laisser) ET Charge camion = Charge camion 0 + PoidsTotal(Lot à charger) ET (Lot à laisser,Lot à charger) = DécompositionOptimale(Lot traité, Charge Max 0 - Charge camion 0 ) ET PoidsTotal(s1,…,sn) = s1+…+sn ET (lot1,lot2)=DécompositionOptimale(lot,ch) SSI … Hypothèse: la spécification des opérations d'ajout et de retrait sur une file sont connues (voir cours de programmation, Baudouin Le Charlier) CONCLUSION: TROP COMPLIQUE!

20 20 Solution: Structurer le problème en décomposant les fonctions TraiterLot Décomposer Lot Calculer Charge Lot Abandonner Lot Retirer Lot Charger Lot

21 21 Décrire les sous-fonctions Décomposer Lot Charger Lot Abandonner Lot Lots à traiter Charge Camion Lot à charger Lot à laisser Retirer Lot Lot suivant Charge Max Charge Lot Charge Camion Lot suivant Lot à laisser Lots à traiter Calculer Charge Lot Lot suivant Charge Lot

22 Types de données Lot, Lot suivant, Lot à charger, Lot à laisser : LOT LOT=SEQ[Integer] Lots à traiter : DOUBLEFILE[LOT] Charge Camion, Charge Max, Charge Lot: Integer

23 23 Enchaînement des fonctions: Traiter Lot Décomposer Lot Charger Lot Abandonner Lot Lots à traiter Lot à charger Lot à laisser Retirer Lot suivan t Charge Max Charge Camion Si Lot à Charger <> [] Si Lot à laisser <> [] DEBUT FIN Calculer Charge Lot Charge Lot

24 24 Structuration: Définition de modules Charge Camion Charge Max Livrer Décomposer Lot Charger Lot Abandonner Lot Lots à traiter Retirer Lot File De Lots Camion Calculer Charge Lot Traiter Lot Simulateur Livreur Arrivée Lot

25 25 Spécifier un module comme un type logique (approche objet): Camion Structure de données Charge Camion: Integer Charge Max: Integer Invariants Globaux: Charge Camion <= Charge Max Opérations: Livrer() Précondition: Charge Camion<>0 Postcondition: Charge Camion=0 Charger Lot(Charge Lot: Integer) Précondition: Charge Max <= Charge Camion +Charge Lot Postcondition: Charge Camion = Charge Camion 0 + Charge Lot …

26 26 Spécifier un module comme un type logique (approche objet): File De Lots Structure de données Lots à Traiter: DOUBLEFILE[LOT] Opérations: Arrivée Lot (Lot: LOT) Précondition: / Postcondition: Lots à Traiter = AjoutFin(Lots à Traiter 0, Lot) Retirer Lot  Lot: LOT Précondition: Lots à Traiter <>[ ] Postcondition: (Lots à Traiter,Lot) = RetraitTête(Lots à Traiter 0 ) Abandoner Lot (Lot: LOT) Précondition: / Postcondition: Lots à Traiter = AjoutTête(Lots à Traiter 0,Lot) … Hypothèse: les opérations sur les doubles files (AjoutFin, AjoutTête et RetraitTête) sont connues.

27 27 Calculer Charge Lot : Spécifier comme Fonction (Pré/Post) Paramètres Entrée: Lot: LOTLOT=SEQ[Integer] Résultats: Charge: Integer Précondition: Lot = [ch 1, … ch n ], n>=0 Postcondition: Charge=SOMME(1..n)(ch i )

28 28 Spécifier Décomposer Lot Fonction (Pré/Post) Paramètre Entrée: Lot suivant : LOT Charge Camion, Charge Max: Integer Résultats: Lot à charger, Lot à laisser: LOT Précondition: Lot suivant <> [] Postcondition: SI (CalculerCharge(Lot suivant)<=Charge Max 0 - Charge camion 0 ) ALORS Lots à charger = Lot suivant SINON (Lot à laisser,Lot à charger) = DécompositionOptimale(Lot suivant 0, Charge Max 0 - Charge camion 0 )

29 Spécifier Traiter Lot: Fonction Pré/Post C'EST PLUS SIMPLE! Objets Utilisés: Lot à Traiter: DOUBLEFILE[LOT] Paramètre Entrée: Charge Camion, Charge Max: Integer Résultats: Lot à Traiter: DOUBLEFILE[LOT] Charge Camion: Integer Variables intermédiaires: Lot suivant, Lot à laisser, Lot à charger: LOT Lots à Traiter Bis: DOUBLEFILE[LOT] Précondition: Lots à Traiter <> [] Postcondition: Les fonctionnalités suivantes ont été exécutées: Retirer Lot(Lot à Traiter0); (Lot à charger, Lot à laisser) = Décomposer Lot (Lot suivant, Charge Camion, Charge Max); Abandonner Lot(Lot à Laisser); Charge Camion = Charger Lot (CalculerChargeLot(Lot à charger));

30 30 Conclusion Motivation et importance de la specification –travail en groupe –clarification du problème Spécification progressive –informel  graphique (structure)  formel Lien entre la conceptualisation et spécification de modules – 2 approches de spécification précises (fonctions/type logiques) Réutilisation –de la spécification d'une sous-fonctions –pour spécifier un fonction complexe