Conteneurs de première classe en Coq
|
|
- Étienne Malenfant
- il y a 8 ans
- Total affichages :
Transcription
1 Conteneurs de première classe en Coq First-Class Containers in Coq Stéphane Lescuyer INRIA Saclay Île-de-France Projet ProVal, ORSAY CEDEX, France RÉSUMÉ. Nous présentons une bibliothèque Coq d ensembles et de dictionnaires finis qui reproduit les fonctionnalités disponibles dans la bibliothèque existante FSets/FMaps mais où la généricité des structures est obtenue via des classes de types et non des modules. Cette architecture permet un usage simplifié de ces structures et facilite la programmation d algorithmes complexes en Coq. ABSTRACT. We present a Coq library for finite sets and maps which brings the same functionalities as the existing FSets/FMaps library, but uses type-classes instead of modules in order to ensure the genericity of the proposed data structures. This architecture facilitates the use of these data structures and more generally the implementation of complex algorithms in Coq. MOTS-CLÉS : classes de types, ensembles finis, dictionnaires finis, Coq KEYWORDS: typeclasses, finite sets, finite maps, Coq
2 134 JFLA Introduction Les assistants de preuve tels Coq [4] ou Isabelle/HOL [8] permettent d exprimer et de prouver formellement des propriétés logiques complexes, mais aussi plus généralement de définir des types et des fonctions sur lesquelles il est ensuite possible de raisonner. Ce sont donc en particulier des langages de programmation et c est une des caractéristiques qui les rend si polyvalents : on peut y définir des programmes, les spécifier formellement, et éventuellement les extraire [10] vers un langage de programmation usuel ou bien les exécuter directement au sein de l assistant de preuve. Cette dernière fonctionnalité est à la base des preuves par réflexion [2] et fournit un moyen très puissant d améliorer l automatisation des preuves interactives. En tant que langage de programmation, il est naturel de doter Coq de bibliothèques de structures de données génériques. En effet, les langages de programmation disposent habituellement de bibliothèques pour manipuler les structures qui reviennent couramment : séquences, ensembles finis, tables d associations, etc. Par exemple, les programmeurs C++ peuvent s appuyer sur la bibliothèque STL [13] (Standard Template Library), tandis que les programmeurs OCaml ont à leur disposition un certain nombre de modules (listes, files, ensembles et dictionnaires finis, tables de hachage,...) dans la bibliothèque standard [1]. La généricité des structures proposées, i.e. le fait qu on puisse les utiliser pour stocker des éléments de types quelconques, est obtenue de manière différente suivant les langages : polymorphisme dans les langages ML, templates en C++ ou encore generics en Java. L implémentation de certaines structures de données efficaces requiert des propriétés particulières sur les éléments, par exemple une fonction de comparaison. Ce type de généricité, appelé polymorphisme ad hoc, est rendu possible par l usage de foncteurs en OCaml, et par celui de classes de types en Haskell [14]. Même s ils peuvent être utilisés pour répondre au même problème, ces deux paradigmes diffèrent fondamentalement et ont chacun des avantages sur l autre [15]. Depuis plusieurs années déjà, Coq dispose d un système de modules similaire à celui d OCaml [3] et P. Letouzey et J-C. Filliâtre l ont mis à profit pour développer une bibliothèque très complète d ensembles et de
3 Conteneurs de 1 ère classe en Coq 135 dictionnaires finis [5]. Nous avons utilisé cette bibliothèque FSets de manière conséquente au sein d un développement Coq [9] et avons rencontré un certain nombre de problèmes inhérents aux modules. Or, Coq a été récemment doté d un système de classes de types fondé sur les enregistrements dépendants [12] et nous avons décidé de tirer profit de cette nouvelle fonctionnalité pour réimplanter la bibliothèque existante FSets à base de classes de types. C est cette librairie que nous présentons et discutons dans cet article. La section 2 présente rapidement le système de classes de types de Coq, ainsi que les problèmes ayant motivés ce travail. Nous introduisons ensuite en section 3 la notion de base de la librairie, à savoir les types ordonnés, avant de décrire comment les structures d ensembles et de dictionnaires finis proprement dites ont été adaptées (section 4). Nous donnons ensuite quelques instantiations concrètes de ces structures, avant de comparer plus précisément notre librairie et la version modulaire en section Préliminaires et motivations 2.1. Classes de types Nous présentons dans cette section le système de classes de types de Coq dans ses grandes lignes ; pour une présentation détaillée, le lecteur intéressé peut se reporter à [12]. Une classe de types permet d empaqueter un certain nombre de définitions et de propriétés, à la manière d un enregistrement 1. Ces classes peuvent être paramétrées, ainsi on peut définir la classe des types disposant d une égalité décidable : Class decidable (A : Type) := { eq : A A bool ; eq_dec : xy, eq x y = true x = y }. 1. et les classes sont d ailleurs implantées par des enregistrements.
4 136 JFLA 2010 Cette classe decidable est paramétrée par un type A et contient une égalité booléenne sur ce type A, ainsi que les preuves adéquates sur cette égalité. Des objets de type decidable sont appelés des instances et sont définis de manière particulière à l aide du mot-clé Instance : Definition bool_eq (x y : bool) := if x then y else negb y. Property bool_eq_dec : xy, bool_eq x y = true x = y. Proof.... Qed. Instance bool_dec : decidable bool := { eq := bool_eq ; eq_dec := bool_eq_dec }. Les champs peuvent aussi être initialisés directement ou prouvés interactivement. Les classes de types prennent tout leur intérêt par la conjonction de deux mécanismes : la possibilité de définir des objets paramétrés par des classes de types et de les utiliser sans instancier explicitement ces paramètres ; le mécanisme d inférence automatique d instances de classes de types à partir des instances déjà définies par l utilisateur. Par exemple, on peut prouver le lemme suivant pour tout type ayant une instance de decidable : Lemma decides_eq {decidable A} : (x y : A), {x = y} + {x y}. Proof.... Qed. Ce lemme est paramétré par un type A et une instance de decidable A mais ces paramètres sont déclarés implicites. Lorsqu on utilise ensuite ce lemme en l appliquant à deux termes d un même type B, une instance de decidable B est automatiquement cherchée à partir des définitions d instances déjà réalisées. Par exemple, on peut écrire le terme decides_eq true false qui sera bien typé et va utiliser implicitement et automatiquement l instance bool_dec définie auparavant. L inférence automatique d instances est particulièrement intéressante lorsqu on définit des familles d instances, ou des instances paramétrées par d autres instances. Par exemple, on peut définir une instance pour tout type produit A B à partir d instances pour les types A et B,
5 Conteneurs de 1 ère classe en Coq 137 et le système pourra alors automatiquement inférer une instance pour tout produit de types décidables : Instance prod_dec {decidable A, decidable B} : decidable (A B) := { eq := fun x y eq (fst x) (fst y) && eq (snd x) (snd y) ; eq_dec :=... }. Check (decides_eq (true, (false, true)) (false, (false, true))). Pour finir, on peut construire des hiérarchies de classes, et un système de coercions automatiques garantit qu une instance d une classe peut être utilisée comme instance de ses sous-classes. Nous verrons un tel exemple dans la section Motivations À la lumière des fonctionnalités offertes par le système de classes de types, nous revenons ici en détail sur les motivations qui nous ont conduits, pour notre développement de solveur SAT décrit en [9], à utiliser ce système à la place de l implantation modulaire FSets déjà disponible. Instantiation automatique. Dans notre développement, nous manipulons des ensembles de nombreux types différents, y compris des ensembles d ensembles, et pour chaque nouveau type le foncteur qui crée un module d ensembles finis doit être appliqué manuellement afin de créer le module adéquat. Ainsi, étant donné des modules de types ordonnés Int, IntPair, BoolList pour les entiers, les paires d entiers et les listes de booléens, on devra écrire 2 : Module IntSet := FSetList.Make Int. Module IntPairSet := FSetList.Make IntPair. Module BoolListSet := FSetList.Make BoolList. 2. FSetList.Make est un foncteur créant une structure d ensemble fini à base de liste ordonnée.
6 138 JFLA 2010 pour pouvoir utiliser des ensembles sur ces trois types d éléments. Cela peut sembler un moindre mal mais on est très vite amenés à instancier également les foncteurs de propriétés sur les types ordonnés et les ensembles finis, qui sont indispensables pour raisonner sur les structures ci-dessus. Module IntFacts := OrderedType.OrderedTypeFacts Int. Module IntSetEqProps := FSetEqProperties.EqProperties IntSet. Module IntSetProps := IntSetEqProps.MP. Module IntSetFacts := IntSetEqProps.MP.Dec.FM. Module IntPairFacts := OrderedTypeFacts IntPair.... Ce type de définitions, que tout utilisateur des FSets a rencontré, devient très rapidement pénible à lire et à maintenir et d autre part les applications de ces foncteurs ne sont pas gratuites et il n est pas rare de passer une poignée de secondes uniquement pour l instantiation de tous ces objets. L instantiation automatique et implicite des instances de classes de type apporte une solution à ce problème. Surcharge. Comme le système de modules n offre pas de surcharge réelle, on fait référence aux membres d un module en les qualifiant du nom du module. Dans le cas ci-dessus, cela signifie que toute utilisation d une fonction, d un lemme ou d un type apportés par ces modules (IntSet, IntPairSet, IntSetProps,...) doit être proprement qualifiés. Cela rend très vite le code très verbeux et peu lisible, et les scripts de preuve très peu compacts. L utilisateur finit souvent par donner des noms très courts à tous ces modules (IS, IPS, ISP,...) et perd alors en lisibilité ce qu il a gagné en verbosité. Par le biais des arguments de classe implicites, le système de classes de types dispense d une telle qualification et permet une vraie surcharge des opérateurs. Efficacité et modularité. Afin de garantir une bonne modularité dans notre développement, certaines parties du système doivent être paramétrées par des modules apportant des types et certaines structures de données sur ces types. Ainsi, il n est pas rare en OCaml d écrire des signatures de ce genre :
7 Conteneurs de 1 ère classe en Coq 139 (* some abstract type *) type t (* finite sets of elements of type t *) module TS = Set.S with type elt = t (* finite maps indexed by elements of type t *) module TM = Map.S with type key = t... En paramétrisant le développement de cette manière dans Coq, nous nous sommes heurtés à un problème d efficacité des modules, à savoir que l application de foncteurs paramétrés par de telles signatures prenait un temps déraisonnable. Ainsi, une application du foncteur final de notre système prenait de l ordre de 15 secondes. Si cela semble être un problème d implémentation 3 de l application des foncteurs (à savoir, par substitution) plutôt qu un problème inhérent aux modules, il n en reste pas moins que c est un problème pratique très limitant et que les classes de types ne souffrent pas de cette limitation. Première classe. Pour approfondir le point précédent, les instances de classes de type de Coq sont de fait des valeurs de première classe, et donc le coût d une instantiation est réduit au typage de l argument (c est juste le passage d un argument à une fonction). Elles permettent donc d envisager une instantiation interactive de procédures paramétrées par des classes de types. Par exemple, l invocation d une tactique réflexive peut commencer par générer une instance dépendant du contexte (comme une formule réifiée ou une table de hashconsing) et la passer à une procédure paramétrée. Ce type d instantiation dynamique est inconcevable avec un foncteur puisque appliquer le foncteur à chaque invocation de la tactique serait rédhibitoire. Parmi ces motivations, les deux premiers points sont inhérents aux modules et aux classes de types tandis que les deux derniers dépendent plutôt de l implémentation. Bien que le troisième soit vraiment celui qui nous a décidé à changer de paradigme, les avantages soulignés par les deux premiers points sont déjà une raison suffisante en pratique. 3. en particulier, utiliser les ensembles finis à base d arbres AVL plutôt que de listes ordonnées multipliait ce temps par quatre sans raison apparente.
8 140 JFLA Types ordonnés Les structures d ensembles et de dictionnaires finis, pour être implantées efficacement, requièrent que le type des éléments soit un type muni d un ordre total décidable. Nous montrons dans cette section comment nous formalisons cette classe de types OrderedType Un type ordonné est un type muni d une égalité (une relation d équivalence), d un ordre strict (une relation transitive et irréflexive) et telle que ces relations sont décidables. Coq fournit déjà une classe Equivalence pour les relations d équivalence, ainsi que les notations x === y (resp. x =/= y) pour les égalités (resp. diségalités) sur ces relations. Nous définissons la classe des ordres stricts modulo une relation d équivalence. Cette classe est paramétrée par le type des éléments, la relation d équivalence et la relation d ordre : Class StrictOrder {A} lt eq {Equivalence eq} := { StrictOrder_Transitive : (x y z : A), lt x y lt y z lt x z ; StrictOrder_Irreflexive : (x y : A), lt x y x =/= y }. La bibliothèque FSets amène deux signatures alternatives pour les types ordonnés, respectivement dans les modules OrderedType (figure 1) et OrderedTypeAlt (figure 2). OrderedType apporte un type t, une relation d équivalence eq et un ordre strict lt sur t, ainsi que les preuves adéquates. La décidabilité est donnée par la fonction compare qui est complètement spécifiée par son type de retour, défini par l inductif Compare : la fonction compare permet donc de comparer deux éléments et retourne également une preuve de la relation de comparaison entre ces deux éléments. Cette formalisation est assez pratique à utiliser, en particulier lorsqu on raisonne par cas sur la comparaison entre deux éléments, les hypothèses correspondant à chaque branche sont ajoutées naturellement. Un inconvénient
9 Conteneurs de 1 ère classe en Coq 141 Inductive Compare {A} lt eq x y := LT : lt x y Compare lt eq x y EQ : eq x y Compare lt eq x y GT : lt y x Compare lt eq x y. Parameter t : Type. Parameter eq : t t Prop. Parameter lt : t t Prop. (* equivalence axioms for eq *)... Axiom lt_trans :... Axiom lt_not_eq : xy, lt x y eq x y. Parameter compare : xy, Compare lt eq x y. Figure 1 Module OrderedType existant Inductive comparison := Lt Eq Gt. Parameter t : Type. Parameter compare : t t comparison. Parameter compare_sym : xy, compare y x = match compare x y with Eq Eq Gt Lt Lt Gt end. Parameter compare_trans : cxyz, compare x y = c compare y z = c compare x z = c. Figure 2 Module OrderedTypeAlt existant possible est que la fonction compare est informative et non purement calculatoire, or elle est utilisée intensément dans les calculs et cela peut être source d inefficacité. Pour assurer une séparation calculs/preuves, OrderedTypeAlt est au contraire centré sur une fonction de comparaison dont le type de retour comparison est le type à trois valeurs Eq Lt Gt. La spécification de cette fonction par les propriétés de symétrie et de transitivité est en revanche assez pénible à utiliser dans les phases de raisonnement.
10 142 JFLA 2010 Afin de garder le meilleur de ces deux alternatives, nous choisissons une fonction de comparaison purement calculatoire, et nous la spécifions séparément à l aide de l inductif suivant : Inductive compare_spec {A} eq lt (x y : A) : comparison Prop := compare_spec_lt : lt x y compare_spec eq lt x y Lt compare_spec_eq : eq x y compare_spec eq lt x y Eq compare_spec_gt : lt y x compare_spec eq lt x y Gt. Contrairement à Compare, cet inductif n est pas le type de retour de la fonction de comparaison, mais relie chaque valeur de comparaison à l hypothèse adéquate. Il suffit alors de prouver que tous les résultats de la fonction de comparaison vérifient cette relation pour l avoir spécifiée correctement. Nous sommes alors en mesure de donner la classe OrderedType des types ordonnés : Class OrderedType (A : Type) := { _eq : relation A ; _lt : relation A ; OT_Equivalence :> Equivalence _eq ; OT_StrictOrder :> StrictOrder _lt _eq ; compare : A A comparison ; compare_dec : xy, compare_spec _eq _lt x y (compare x y) }. Cette classe est paramétrée par le type A des éléments et contient les relations d égalité et d ordre strict. Des sous-classes Equivalence et StrictOrder (introduites par :>) sont utilisées pour spécifier ces relations. Enfin, la fonction de comparaison et sa spécification sont introduites comme expliqué ci-dessus. Cette spécification est aussi simple à utiliser que l originale malgré le type non informatif de la fonction compare : en effet, dans un contexte où compare a b apparaît, il suffit d invoquer destruct (compare_dec a b) pour raisonner par cas sur cette comparaison : compare a b est alors remplacé dans chaque branche par sa valeur, et l hypothèse correspondante est ajoutée au
11 Conteneurs de 1 ère classe en Coq 143 contexte. L inductif compare_spec est similaire aux vues réflexives de l extension SSREFLECT [7]. 4 Une fois les classes définies, de nombreux lemmes utiles (comme le fait que l ordre est un morphisme pour l égalité) et des notations sont établis et peuvent être utilisés pour n importe quel type ordonné. La table suivante récapitule les notations disponibles et les vues correspondantes : Notation Signification Vue x =?= y compare x y compare_dec x == y true ssi x =?= y renvoie Eq eq_dec x << y true ssi x =?= y renvoie Lt lt_dec x >> y true ssi x =?= y renvoie Gt gt_dec 3.2. Égalités particulières Lorsqu on écrit du code paramétré par un type ordonné, il est très fréquent de requérir qu un certain type soit ordonné en contraignant la relation d égalité à être une égalité particulière, et très souvent l égalité de Leibniz. Le système de modules permet d exprimer une telle contrainte via la restriction de signature OrderedType with Definition eq :=... Malheureusement, ce type de contraintes n est pas exprimable avec les classes de types ; pour ce faire, il faut que la partie que l on veut contraindre soit un paramètre de la classe de type et non un membre. Pour traiter ces cas particuliers, on introduit une classe particulière SpecificOrderedType paramétrée par la relation d équivalence souhaitée, et on montre que tout type de cette classe est aussi un OrderedType : Class SpecificOrderedType (A : Type) (eqa : relation A) (Equivalence A eqa) := { SOT_lt : relation A ; SOT_StrictOrder : StrictOrder SOT_lt eqa ; SOT_compare : A A comparison ; 4. cette discussion se rapporte à la version 8.2 de Coq ; la prochaine version devrait introduire une signature mixte tirant profit des classes de types et de compare_spec.
12 144 JFLA 2010 SOT_compare_spec : xy, compare_spec eqa SOT_lt x y (SOT_compare x y) }. Instance SOT_as_OT {SpecificOrderedType A} : OrderedType A := {... }. On ajoute également une notation UsualOrderedType pour dénoter le cas particulier fréquent de l égalité de Leibniz. Ces types ordonnés à égalité spécifique seront utiles pour définir les conteneurs dans la section Génération d instances Après que les classes et les propriétés génériques ont été définies, nous déclarons des instances d OrderedType pour tous les types de bases et les constructeurs de type usuels. Lorsque c est possible, nous déclarons des instances d UsualOrderedType, y compris pour les constructeurs de type 5. La librairie fournit des instances pour : les entiers Peano, les entiers binaires (strictement positifs, naturels et relatifs), les rationnels, les booléens, les listes, les produits, les sommes et les options. Ainsi, les fonctions génériques sur les types ordonnés peuvent être utilisées sur toutes les combinaisons de ces constructeurs et types de bases sans aucune intervention manuelle, grâce à l inférence automatique des classes de types : Goal (x y : ((nat bool) + (list Z Q))), x === y. Un type comme ci-dessus sera fréquemment défini directement comme un inductif à deux branches Inductive t := C1 : nat bool t C2 : list Z Q t. Le système des classes de types ne peut pas inférer d instances automatiquement pour des types inductifs, mais nous avons implanté en 5. par exemple, si A et B sont des types ordonnés pour l égalité de Leibniz, alors leur produit ou leur somme également.
13 Conteneurs de 1 ère classe en Coq 145 OCaml une commande vernaculaire qui peut traiter ce genre de cas automatiquement. Cette commande Generate OrderedType prend un type inductif en argument, génère relations d équivalence et d ordre strict, fonction de comparaison et toutes les preuves nécessaires avant de déclarer l instance de type ordonné correspondant. Elle utilise pour ce faire toutes les instances déjà disponibles dans l environnement. Les constructeurs sont ordonnés arbitrairement, et les paramètres d un même constructeur sont ordonnés lexicographiquement 6. La commande fonctionne avec les inductifs (mutuellement) récursifs et les paramètres uniformes, ce qui en fait un ajout très utile à la bibliothèque. Par exemple, les commandes suivantes montrent son utilisation pour comparer des chaînes de caractères : Generate OrderedType ascii. Generate OrderedType string. (* string utilise ascii *) Eval vm_compute in ( longue =?= petite ). (* ce calcul renvoie Lt *) 4. Ensembles et dictionnaires finis Les types ordonnés décrits dans la section 3 sont une classe de types sur lesquels il est possible d implémenter un certain nombre de structures efficaces de conteneurs de données. Le but de la bibliothèque est de fournir ce type de structure, nous définissons maintenant leur interface Interfaces et spécifications La classe des ensembles finis contenant des éléments d un type ordonné A est définie de la manière suivante : Class FSet {H : OrderedType A} := { set : Type ; In : A set Prop ; 6. mais la commande est typiquement utilisée dans les cas où n importe quel ordre bien défini convient, à l instar de Pervasives.compare en OCaml.
14 146 JFLA 2010 empty : set ; mem : A set bool ; add : A set set ;... FSet_OrderedType :> SpecificOrderedType _ (Equal_pw set A In) _ }. Implicit Arguments set [[H] [FSet]]. Cette classe paramétrée 7 par le type A et une instance d OrderedType A apporte le type set des ensembles finis de A et les différents opérateurs disponibles sur ces ensembles. Le champ In est le prédicat d appartenance à l ensemble et est la seule partie propositionnelle de cette classe : tous les opérateurs vont être spécifiés en fonction de ce prédicat. Le champ FSet_OrderedType nécessite des explications : il garantit que le type set des ensembles d éléments de A est lui-même un type ordonné, qui plus est un type ordonné pour une égalité bien particulière, en introduisant une sous-classe SpecificOrderedType comme expliqué en section 3.2. Cette égalité est l égalité point à point pour l opérateur d appartenance In, définie ainsi pour tout type de conteneur ctr et d éléments elt : Definition Equal_pw (ctr elt : Type) (In : elt ctr Prop) (s s : ctr) : Prop := a : elt, In a s In a s. Ces définitions permettent de considérer des ensembles comme des types ordonnés, en écrivant par exemple s === empty, et assure que cette égalité est convertible avec l égalité point à point, qui est celle utilisée dans la librairie FSets originalement. Étant donné une instance de FSet pour un type ordonné A, on peut alors manipuler des ensembles facilement : Definition add_all (x y z : A) (s : set A) := add x (add y (add z s)). 7. ce choix, loin d être bénin, est discuté en section 6.
15 Conteneurs de 1 ère classe en Coq 147 Lors des manipulations de preuve, il n est pas souhaitable que l instance de FSet utilisée soit dévoilée à l utilisateur, i.e. que les projections set, add, etc, soient réduites. Pour cela, nous rendons opaques les différentes projections de la classe FSet 8 : Global Opaque set In empty mem.... La classe FSet ne contient que l interface calculatoire de la structure d ensembles finis et non sa spécification. Le choix a été fait de séparer interface et spécifications pour des raisons pragmatiques : les définitions de fonctions et d algorithmes peuvent se contenter de l interface calculatoire, qui reste ainsi relativement petite, tandis que seules les phases de preuve nécessiteront les spécifications. Avant de définir ces spécifications, nous pouvons déja définir un certain nombre de prédicats et de notations génériques sur les ensembles finis, parmi lesquelles Equal s t pour l égalité point à point et Subset s t pour l inclusion. Les notations disponibles sont énumérées dans la table 3. s [=] t Equal s t s [<=] t Subset s t v s In v s {} empty {v} singleton v {v ; s} add v s {s v} remove v s v in s mem v s s ++ t union s t s \ t diff s t Figure 3 Notations disponibles pour les ensembles finis L ensemble des spécifications des opérations fournies par la classe FSet pourrait être empaqueté dans une grande classe FSetSpecs paramétrée par FSet, mais nous choisissons plutôt de spécifier chaque 8. cela ne bloque pas le calcul avec compute ou vm_compute, mais les δ-conversions réalisées par certaines tactiques.
16 148 JFLA 2010 opération dans une classe à part. Ainsi, les spécifications des opérations empty et add sont décrites par les classes suivantes : Class FSetSpecs_empty (FSet A) := { empty_1 : Empty empty }. Class FSetSpecs_add (FSet A) := { add_1 : s x y, x === y In y (add x s) ; add_2 : s x y, In y s In y (add x s) ; add_3 : s x y, x =/= y In y (add x s) In y s }. Nous faisons ce choix pour deux raisons. Tout d abord, il est très fréquent en pratique d interroger le système sur les lemmes disponibles à propos d un certain identificateur, par exemple add, à l aide de la commande SearchAbout add par exemple. Si toutes les spécifications (une cinquantaine) sont regroupées dans une seule classe, cette commande va malheureusement afficher les objets énormes que sont le constructeur de la classe et les principes d élimination de cette classe, ce qui la rend inutilisable. En regroupant les spécifications par fonction, seuls les lemmes pertinents sont affichés par la commande. L autre raison est que ce choix permet en général de n avoir des preuves qui ne dépendent que du strict nécessaire : ainsi, si une structure d ensemble particulière ne fournit pas certaines opérations d ensembles mais que celles-ci ne sont pas utilisées, un développement peut tout de même s appuyer sur l interface générique puisque seules les spécifications de certaines opérations sont manquantes. A l extrême on peut imaginer un développement sur lequel aucune preuve n est nécessaire (qui est utilisée comme oracle pour une autre partie du système) et qui ne demanderait aucune spécification mais se contenterait d utiliser l interface FSet. Pour les développements qui nécessiteraient au contraire l interface complète de toutes les opérations, on définit une classe qui est une superclasse de toutes les spécifications : Class FSetSpecs (F : FSet A) := { FFSetSpecs_In :> FSetSpecs_In F ; FFSetSpecs_mem :> FSetSpecs_mem F ; FFSetSpecs_add :> FSetSpecs_add F ;
17 Conteneurs de 1 ère classe en Coq }. Conjointement, cette classe de spécifications et la classe FSet correspondent exactement à l interface FSetInterface.S de la librairie existante. Dictionnaires finis. Nous ne présentons ici que l interface des ensembles finis pour des raisons de concision, mais l interface des dictionnaires finis est adaptée de manière similaire à partir de celle de la bibliothèque existante. En particulier, les mêmes choix sont faits quant à la séparation interface/spécifications et la modélisation des spécifications Les bibliothèques de propriétés La librairie FSets contient plusieurs modules de résultats généraux sur les structures d ensembles finis : FSetFacts, FSetDecide, FSetProperties, FSetEqProperties. L adaptation de ces modules aux interfaces à base de classes de type présentées précédemment représentait un bon test pour étalonner la facilité d usage de cette présentation. Tous ces modules ont été adaptés sans problème majeur, le point le plus délicat étant certainement FSetDecide et sa tactique fsetdec contribuée par A. Bohannon. Il faut noter que, alors que la tactique originale s intéressait à un seul type d ensemble à la fois, la tactique de notre librairie traite toutes les hypothèses se référant à des ensembles finis dans le contexte et cela peut conduire à quelques incompatibilités. Tous les lemmes et toutes les propriétés ont gardé le même nom que dans la librairie originale, ce qui minimise la quantité de travail nécessaire pour porter un code de la version modulaire à la version présentée ici (cf. Section 6.3). Un certain nombre de propriétés ont été ajoutées pour faciliter le raisonnement par cas sur des fonctions comme mem, choose ou min_elt, à l aide de vues inductives de leur spécification. Par exemple, la spécification de la fonction choose est disponible de cette façon :
18 150 JFLA 2010 Inductive choose_spec (s : set elt) : option elt Prop := choose_spec_some : x (Hin : In x s), choose_spec (Some x) choose_spec_none : (Hempty : Empty s), choose_spec None. Property choose_dec : s, choose_spec (choose s). et s utilise facilement en raisonnant par cas sur le résultat de choose_dec. 5. Applications 5.1. Listes et arbres AVL La bibliothèque existante FSets propose deux types d implantations d ensembles et de dictionnaires finis, les unes fondées sur des listes triées et les autres sur des arbres de recherche équilibrés (AVL) [6]. Nous avons transposé les ensembles et les dictionnaires à base de listes, ainsi que ceux à base d AVL. Détaillons par exemple le cas des ensembles à base de listes. En pratique, le développement des listes triées est le même dans la version modulaire et dans notre version à classes de types et ils ne diffèrent que marginalement 9. Ainsi, alors que le code original des listes est un foncteur paramétré par un module de signature OrderedType, le code des listes triées à base de classes de type est en fait paramétré par rapport à une instance de la classe OrderedType. Cela se fait en utilisant le mécanisme de sections de Coq et la commande Context qui permet d introduire des variables d instance dans une section : 9. il est alors naturel de s interroger sur la problématique de duplication de code entre les deux développements ; nous discutons ce point dans la section 6.
19 Conteneurs de 1 ère classe en Coq 151 Version modulaire Version à base de classes Module Make (X : OrderedType) <: S with Module E := X. Module E := X. Definition elt := X.t.... End Make. Section Make. Context {OrderedType elt}.... End Make. Dans le contexte {OrderedType elt}, elt est un type frais et disposant d un ordre décidable. Les définitions de la section peuvent donc utiliser elt comme un type ordonné, et elles sont automatiquement généralisées pour tout type ordonné à la fermeture de la section. Une fois que les définitions des listes triées et des différentes opérations, ainsi que les preuves adéquates, ont été réalisées, il ne reste plus qu à définir les instances correspondant aux classes présentées dans la section 4.1. On peut empaqueter toutes ces définitions dans un module particulier SetList, qui n a pas à être importé par l utilisateur, puisque seules les instances implémentant l interface sont nécessaires. Dans le cas des listes triées, qui fournissent une structure d ensembles pour n importe quel type ordonné, on peut définir une instance générique paramétrée par un type ordonné : Instance SetList_FSet {Helt : OrderedType elt} : FSet := { set := SetList.set elt ; In elt Helt ; empty :=... }. Cette définition déclare bien une famille d ensembles finis, ou autrement dit une manière d obtenir une structure d ensemble fini sur elt pour tout type ordonné elt. De même, on déclare une famille de spécifications pour chacune de ces structures indexées par un type ordonné elt : Instance SetList_FSetSpecs {Helt : OrderedType elt} : FSetSpecs SetList_FSet := {
20 152 JFLA 2010 FFSetSpecs_In :=... ; FFSetSpecs_mem :=... ;... }. Une fois ces instances définies dans un fichier (ou plus généralement un module), il suffit d importer ce module et on peut alors utiliser des ensembles finis sur n importe quel type ordonné Utilisation La simplicité d utilisation de notre bibliothèque est un de ses principaux intérêts. Pour travailler avec des ensembles finis, il suffit d importer le module Sets qui exporte les fonctionnalités suivantes : la notion de type ordonné, ainsi que la bibliothèque de résultats et d instances associés ; les instances génériques des ensembles finis à base d arbres AVL ; les interfaces, spécifications, notations et propriétés relatives aux ensembles finis. Une première remarque est que ce sont donc les AVL qui sont chargés par défaut lorsqu on importe ce fichier. Cela est justifié par le fait que les AVL sont plus efficaces en général que les listes triées, et il n y a aucune pénalité en terme de temps de chargement par rapport à l utilisation des listes triées. Cela diffère de la bibliothèque existante où l application des foncteurs d arbres AVL est beaucoup plus longue que celle des foncteurs de listes triées. Un utilisateur qui souhaiterait malgré tout utiliser les listes triées peut se contenter de charger les instances adéquates ; il peut également spécifier manuellement quelle instance utiliser si les circonstances l imposent 10. Un module Maps existe également qui charge de manière similaire toute l infrastructure nécessaire pour utiliser les dictionnaires finis ; il charge en particulier les dictionnaires à base d AVL. 10. le gain en verbosité par rapport aux modules peut alors disparaître, mais cette instantiation explicite peut être évitée le plus souvent.
21 Conteneurs de 1 ère classe en Coq 153 Une fois Sets chargé, on peut utiliser toutes les définitions et notations génériques sur les ensembles finis, en les utilisant sur des types ordonnés. Si de plus les instances d OrderedType peuvent être inférées automatiquement comme décrit à la section 3.3, ce qui est le cas pour la plupart des types habituels, alors l utilisation d ensembles finis devient tout à fait transparente pour l utilisateur, à l instar de structures polymorphes comme les listes. L exemple suivant montre le calcul d un ensemble d entiers : Require Import Sets. Fixpoint fill n s := match n with O s S n 0 fill n 0 {n 0 ; s} end. Eval vm_compute in mem 6 (fill 7 {42}). (* ce calcul renvoie true *) Des ensembles finis de différents types peuvent cohabiter sans problème dans les mêmes fonctions, et en particulier grâce au membre FSet_OrderedType de la classe FSet (cf. 4.1), on peut manipuler des ensembles d ensembles : Definition map_fill (s : set nat) : set (set nat) := fold (fun n S {fill n {} ; S}) s {}. Eval vm_compute in cardinal (map_fill (fill 3 {})). (* ce calcul renvoie 3 *) L utilisation des lemmes de la bibliothèque se fait de manière tout aussi facile lors des preuves, par exemple pour appliquer la première partie de la spécification de l opération add, il suffit d appliquer le lemme et les arguments implicites sont correctement inférés : Goal (x : option nat) s, In x {x ; s}. Proof. intro ; apply add_1 ; reflexivity. Qed. Pour conclure cette section, voilà un exemple d utilisation des dictionnaires finis et de quelques notations associées. Le type des dictionnaires
22 154 JFLA 2010 associant des valeurs de type elt à des clés key est Map[key, elt]. La notation s[k v] dénote l ajout (ou la mise à jour) d une association dans le dictionnaire s, [] le dictionnaire vide et s[k] la valeur associée à k dans s si elle existe. Require Import Maps. Fixpoint fill (s : Map[nat,nat]) (n : nat) := match n with O s S n 0 fill s[n 0 S n 0 ] n 0 end. Eval vm_compute in (fill [] 7)[4]. (* ce calcul renvoie Some 5 *) La bibliothèque est disponible à l adresse suivante : fr/~lescuyer/containers.fr.html. 6. Discussion Dans cette section, nous revenons sur la comparaison entre notre bibliothèque et celle existante, et discutons un certain nombre de choix et de limites dans l implantation actuelle Performances Afin de comparer les performances de notre bibliothèque par rapport à l implantation à base de modules, la bibliothèque comprend un fichier BenchMarks.v qui teste les fonctions de base des ensembles finis. Le test consiste en la création d un ensemble d entiers à partir d une séquence générée pseudo-aléatoirement, puis de tests d appartenance dans l ensemble obtenu. Ce processus est répété pour les ensembles à base de classes de types et ceux à base de modules. Le résultat est satisfaisant puisque lorsque les fonctions de comparaison des éléments
23 Conteneurs de 1 ère classe en Coq 155 sont les mêmes 11, les deux alternatives calculent exactement à la même vitesse. Pour comprendre pourquoi le simple fait que les performances sont conservées est satisfaisant, il faut remarquer que le côté très pratique et concis de l utilisation des classes de types se fait aux dépens de la taille des termes. En effet, le caractère implicite des arguments de classes de types ne doit pas faire oublier que ces arguments sont bien présents, et que les instances correspondantes doivent être passées et réduites lors des calculs. Par exemple, la simple expression {1 ; {}} (ou add 1 empty) qui dénote l ajout de l entier 1 dans l ensemble vide correspond en fait à l expression absconse suivante nat (@SOT_as_OT nat (@eq nat) (@eq_equivalence nat) nat_orderedtype) (@SetAVLInstance.SetAVL_FSet nat (@SOT_as_OT nat (@eq nat) (@eq_equivalence nat) nat_orderedtype)) 1 (@empty nat (@SOT_as_OT nat (@eq nat) (@eq_equivalence nat) nat_orderedtype) (@SetAVLInstance.SetAVL_FSet nat (@SOT_as_OT nat (@eq nat) (@eq_equivalence nat) nat_orderedtype))) alors que l expression correspondante dans les modules serait simplement : NatSet.add 1 NatSet.empty Les applications de foncteurs sont donc remplacées par des applications d arguments supplémentaires dans tous les opérateurs. 11. certaines fonctions de comparaison, pour les entiers relatifs notamment, n étant pas purement calculatoires dans la librairie standard, leur performance pouvait être jusqu à cinq fois moindre que celles purement calculatoires de notre formalisation. Cela ne dénote pas d une différence significative entre modules et classes de types, mais souligne l intérêt d avoir une interface qui encourage à écrire des fonctions de comparaison purement calculatoires.
24 156 JFLA 2010 Si les performances des calculs ne souffrent pas de cette complexité cachée, ce n est malheureusement pas le cas du temps mis à typer ces objets lors de la compilation d un fichier ou simplement lors des preuves interactives où ils sont manipulés. Nous revenons sur ce point infra en section 6.4. Nous avons en outre adapté notre développement d un solveur SAT entièrement réflexif [9] à notre bibliothèque, et n avons vu aucun changement sur les nombreux test de performances de la tactique dont nous disposions. Comme cette procédure fait un usage très important des structures d ensemble fini, cela confirme bien que la vitesse des calculs n est pas affectée par rapport à la bibliothèque existante Mise à jour de code existant La mise à jour de notre solveur SAT (et également d autres parties d un système plus large) représentait un bon étalon pour juger de la facilité à adapter du code existant, fondé sur FSets/FMaps, à notre bibliothèque alternative. La base de code est en effet d environ lignes de Coq et utilise différents types d ensembles finis, y compris des ensembles d ensembles. La conclusion de cette expérience était très positive puisque la mise à jour du code existant s est passée sans aucun problème. De manière générale, les noms de lemmes et d opérateurs ayant bien été conservés entre la bibliothèque existante et la nôtre, les modifications à apporter au code sont quasiment automatiques : pour toutes les définitions de modules vérifiant la signature OrderedType, définir l instance OrderedType correspondante 12 ou utiliser les foncteurs décrits dans la section suivante ; remplacer les occurrences des types d ensembles comme NatSet.t par set nat ; remplacer destruct compare par destruct compare_dec dans les preuves ; 12. et ce, seulement si elle ne peut pas déjà être inférée automatiquement par le système, ou bien encore générée par la commande Generate OrderedType.
25 Conteneurs de 1 ère classe en Coq 157 déqualifier toutes les références à des objets appartenant à des modules d ensembles finis ou de propriétés, par exemple remplacer toute référence à NatSet.add, au lemme NatSet.add_3 ou à la tactique NatSetDec.fsetdec par add, add_3 et fsetdec. Ces modifications ne posent pas de problème et rendent le développement plus concis et plus lisible, et ne devraient pas être un frein à l adaptation d une base de code existante à notre bibliothèque Partage de code Lors de la présentation de l interface en section 4 et des implémentations concrètes en section 5, nous avons souligné le fait que les bibliothèques de propriétés génériques ainsi que les constructions de listes et d arbres AVL étaient exactement les mêmes que dans la bibliothèques existante, et qu il était seulement nécessaire de les adapter légèrement aux classes de types. Il est donc naturel de s interroger sur la duplication de code ainsi produite entre notre travail et la bibliothèque déjà disponible : il ne serait pas souhaitable que le code restât ainsi dupliqué. Cela forcerait une maintenance pénible des modifications faites dans une des deux versions. Afin de partager un maximum de code, on peut se contenter d écrire uniquement les versions basées sur les classes de types, puis d en déduire à moindres frais les versions modulaires. Nous montrons cette construction sur l exemple des types ordonnés. Étant donné les définitions de la signature OrderedType et de la classe de type OrderedType données en section 3, on peut construire le foncteur suivant qui transforme toute instance de classe OrderedType en un module de signature OrderedType : Module Type S. Parameter t : Type. Instance Ht : OrderedType t. End S. Module OT_to_FOT (Import X : S) < : OrderedType. Definition t := t.
26 158 JFLA 2010 Definition eq : t t Prop := _eq. Definition lt : t t Prop := _lt. Definition eq_refl : (x : t), eq x x := reflexivity. Definition eq_sym : (x y : t), eq x y eq y x := symmetry.... Definition compare : x y, Compare lt eq x y. Proof.... Qed. End OT_to_FOT. La signature S permet juste d empaqueter un type ordonné avec son instance dans un module. Le foncteur proprement dit est ensuite paramétré par un module de cette signature S, i.e. par le type ordonné, et crée un module de signature OrderedType pour le type et les relations données. L instance et les définitions pour un certain type ordonné t peuvent donc être définies une seule fois, et l utilisateur de la bibliothèque modulaire peut obtenir un module adéquat via ce foncteur. Il est intéressant de noter que l on peut également réaliser la construction réciproque, c est-à-dire un foncteur paramétré par un module OrderedType et qui retourne un module contenant simplement l instance correspondante. Cette construction a évidemment beaucoup moins d intérêt puisqu elle requiert de l utilisateur qu il définisse chaque instance explicitement via l application de ce foncteur. Le foncteur OT_to_FOT, au contraire, n est pas plus contraignant à utiliser que le système à base de modules existant. Le partage réalisé de cette manière peut être généralisé aux autres parties du système, ainsi on pourrait définir un foncteur qui retourne un module d ensemble fini pour un type A à partir d une instance de FSet A. On n aurait ainsi qu à dupliquer les interfaces des différentes parties du système, tout en partageant les implantations concrètes. Notre bibliothèque contient un module Bridge qui contient de tels foncteurs pour les types ordonnés.
27 Conteneurs de 1 ère classe en Coq Paramétrisation de l interface Dans la section 4.1, nous avons choisi de paramétrer la classe FSet par un type d élément ordonné. Nous aurions également pu écrire la classe FSet sans ce paramètre, de la manière suivante : Class FSet := { set : A {OrderedType A}, Type ; In : {OrderedType A}, A set A Prop ; empty : {OrderedType A}, set A ;... }. Cette classe s interprète légèrement différemment de celle définie dans la section 4.1 : elle n est plus paramétrée par un type ordonné, mais chacun de ses membres l est. Une instance de cette classe fournit donc des structures d ensembles finis pour n importe quel type ordonné et non pas pour un seul. Par exemple, les listes triées et les arbres AVL de la section 5.1 sont des instances potentielles de cette classe, tandis que des structures spécifiques comme des arbres de Patricia [11] ne le sont pas. L avantage d une telle formalisation est de pouvoir utiliser différentes instances au sein même de la classe, par exemple on peut y ajouter une opération map : map : {OrderedType A, OrderedType B}, (A B) set A set B ce qui n est pas possible dans l autre cas, où même avec des modules. Il nous semble que ce type d avantage est moins important que la capacité de pouvoir définir des structures spécifiques à certains types, en particulier les entiers, et nous avons donc préféré la formalisation où FSet est paramétrée. Ce choix a malheureusement une conséquence sur la taille des termes créés à l utilisation de la librairie. Nous avons illustré dans la section 6.1 comment les arguments implicites de classes de types venaient grossir les termes de manière cachée. Cet effet est amplifié par la paramétrisation de la classe FSet : en effet, tous les opérateurs de la classes FSet se retrouvent également paramétrés de la même manière et le type or-
28 160 JFLA 2010 donné se retrouve passé deux fois en argument. Par exemple, si F est une instance générique de FSet et nat_ot est de type OrderedType nat, l expression add 5 {} est en F nat nat_ot 5 (@empty F nat nat_ot) dans le cas non paramétré tandis qu elle nat nat_ot (F nat nat_ot) 5 (@empty nat nat_ot (F nat nat_ot)) dans le cas paramétré. La différence peut sembler minime mais non avons mesuré précisément son effet sur un développement utilisant intensément les ensembles finis et la taille totale des preuves et définitions du fichier a augmenté de près de 40%, ainsi que le temps de compilation dudit fichier. Cette augmentation de la complexité des termes et du temps de typage est un des seuls désavantages de l usage des classes de type, et il est regrettable qu il se trouve ici amplifié par la paramétrisation (souhaitable) de la classe FSet 13. En pratique, le temps gagné sur l instantiation des foncteurs dépassait tout de même le temps perdu à cause de la taille des termes Classes de types et modules Le travail présenté ici ne se veut pas une critique générale des modules par rapport aux classes de types, et encore moins une critique de la bibliothèque existante. Comme démontré dans [15], les modules et les classes de types ne sont pas interchangeables et chacun peut se prévaloir d avantages sur l autre. En particulier, les modules permettent un très bon contrôle de l espace de nommage, ce que ne permettent pas les classes de types. Les modules sont très bien adaptés pour découper des systèmes en parties de taille réduite et aux interfaces bien définies ; les foncteurs permettent de remplacer facilement une de ces boîtes par une autre ayant la même interface et ceci peut se révéler d une grande 13. on peut noter que les arguments qui se retrouvent dupliqués sont typés dans le même contexte, et donc qu une forme de hash-consing ou de memoization dans le typage de Coq annulerait les effets négatifs provoqués par ces arguments.
29 Conteneurs de 1 ère classe en Coq 161 aide pour tester plusieurs alternatives au sein d un grand système par exemple. Nous utilisons fortement le système de modules à cet effet dans [9] et il répond parfaitement à nos attentes. En revanche, nous pensons que les structures de données génériques, comme les ensembles et les dictionnaires finis, ne sont pas adaptés à un design modulaire car il est fréquent d avoir besoin conjointement de nombreuses instances de ces structures, ce qui soulève les problèmes rappelés en section 2.2. Il nous semble donc intéressant de profiter de l introduction des classes de types dans le système Coq pour proposer une présentation alternative de ces structures qui tire partie des classes de types Travail futur La bibliothèque que nous proposons n est pas encore complète visà-vis de la bibliothèque existante. En particulier, elle ne dispose d aucun support pour les types à égalité décidable mais sans ordre : la bibliothèque FSets/FMaps supporte ces types particuliers et fournit des structures moins efficaces que pour les types ordonnés, les ensembles et dictionnaires faibles. Nous n avons pas implémenté ces structures faibles car nous nous placions dans l optique d une bibliothèque pour un langage de programmation, et qu il nous semble que dans la grande majorité des cas, les types que l on souhaite manipuler dans ces structures peuvent être ordonnés totalement, au moins arbitrairement. Il serait néanmoins intéressant de les ajouter afin d offrir les mêmes fonctionnalités que ce qui existe actuellement. On peut noter que indépendamment des structures de conteneurs, le support apporté par la bibliothèque pour les types ordonnés peut s avérer utile dans de nombreuses occasions. La bibliothèque pourrait également être enrichie de nouvelles structures : de nouvelles implémentations des classes existantes, par exemple des ensembles de Patricia 14 pour les entiers binaires, ou encore des 14. ils sont disponibles dans la bibliothèque comme une instance de FSet mais sans spécifications.
Chapitre VI- La validation de la composition.
Chapitre VI- La validation de la composition. Objectifs du chapitre : Expliquer les conséquences de l utilisation de règles de typage souples dans SEP. Présenter le mécanisme de validation des connexions
Plus en détailUne introduction rapide à Coq
Une introduction rapide à Coq Yves Bertot Janvier 2009 1 Démarrer le système Pour utiliser Coq on dispose de trois commandes, une commande qui sert à compiler des fichiers (coqc), une commande qui fournit
Plus en détail# let rec concat l1 l2 = match l1 with [] -> l2 x::l 1 -> x::(concat l 1 l2);; val concat : a list -> a list -> a list = <fun>
94 Programmation en OCaml 5.4.8. Concaténation de deux listes Définissons maintenant la fonction concat qui met bout à bout deux listes. Ainsi, si l1 et l2 sont deux listes quelconques, concat l1 l2 constitue
Plus en détailVérification de programmes et de preuves Première partie. décrire des algorithmes
Vérification de programmes et de preuves Première partie. décrire des algorithmes Yves Bertot September 2012 1 Motivating introduction A partir des années 1940, il a été compris que l on pouvait utiliser
Plus en détailClasses et Objets en Ocaml.
Classes et Objets en Ocaml. Didier Rémy 2001-2002 http://cristal.inria.fr/ remy/mot/2/ http://www.enseignement.polytechnique.fr/profs/informatique/didier.remy/mot/2/ Cours Exercices Slide 1 1. Objets 2.
Plus en détailSuivant les langages de programmation, modules plus avancés : modules imbriqués modules paramétrés par des modules (foncteurs)
Modularité Extensions Suivant les langages de programmation, modules plus avancés : modules imbriqués modules paramétrés par des modules (foncteurs) généricité modules de première classe : peuvent être
Plus en détailTP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile
TP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile Dans ce TP, vous apprendrez à définir le type abstrait Pile, à le programmer en Java à l aide d une interface
Plus en détailRecherche dans un tableau
Chapitre 3 Recherche dans un tableau 3.1 Introduction 3.1.1 Tranche On appelle tranche de tableau, la donnée d'un tableau t et de deux indices a et b. On note cette tranche t.(a..b). Exemple 3.1 : 3 6
Plus en détailIN 102 - Cours 1. 1 Informatique, calculateurs. 2 Un premier programme en C
IN 102 - Cours 1 Qu on le veuille ou non, les systèmes informatisés sont désormais omniprésents. Même si ne vous destinez pas à l informatique, vous avez de très grandes chances d y être confrontés en
Plus en détailCours 1 : La compilation
/38 Interprétation des programmes Cours 1 : La compilation Yann Régis-Gianas yrg@pps.univ-paris-diderot.fr PPS - Université Denis Diderot Paris 7 2/38 Qu est-ce que la compilation? Vous avez tous déjà
Plus en détailDéfinitions. Numéro à préciser. (Durée : )
Numéro à préciser (Durée : ) On étudie dans ce problème l ordre lexicographique pour les mots sur un alphabet fini et plusieurs constructions des cycles de De Bruijn. Les trois parties sont largement indépendantes.
Plus en détailCours de Programmation 2
Cours de Programmation 2 Programmation à moyenne et large échelle 1. Programmation modulaire 2. Programmation orientée objet 3. Programmation concurrente, distribuée 4. Programmation monadique 5. Les programmes
Plus en détailVérification formelle de la plate-forme Java Card
Vérification formelle de la plate-forme Java Card Thèse de doctorat Guillaume Dufay INRIA Sophia Antipolis Cartes à puce intelligentes Java Card : Environnement de programmation dédié. Dernières générations
Plus en détailPremiers Pas en Programmation Objet : les Classes et les Objets
Chapitre 2 Premiers Pas en Programmation Objet : les Classes et les Objets Dans la première partie de ce cours, nous avons appris à manipuler des objets de type simple : entiers, doubles, caractères, booléens.
Plus en détailPrincipe de symétrisation pour la construction d un test adaptatif
Principe de symétrisation pour la construction d un test adaptatif Cécile Durot 1 & Yves Rozenholc 2 1 UFR SEGMI, Université Paris Ouest Nanterre La Défense, France, cecile.durot@gmail.com 2 Université
Plus en détailLangage et Concepts de Programmation Objet. 1 Attributs et Méthodes d instance ou de classe. Travaux Dirigés no2
Langage et Concepts de Programmation Objet Travaux Dirigés no2 Pôle Informatique École Nationale Supérieure des Mines de St-Etienne Vous trouverez plus de détails sur les concepts abordés lors de ce TD
Plus en détailUtilisation d objets : String et ArrayList
Chapitre 6 Utilisation d objets : String et ArrayList Dans ce chapitre, nous allons aborder l utilisation d objets de deux classes prédéfinies de Java d usage très courant. La première, nous l utilisons
Plus en détailPrénom : Matricule : Sigle et titre du cours Groupe Trimestre INF1101 Algorithmes et structures de données Tous H2004. Loc Jeudi 29/4/2004
Questionnaire d'examen final INF1101 Sigle du cours Nom : Signature : Prénom : Matricule : Sigle et titre du cours Groupe Trimestre INF1101 Algorithmes et structures de données Tous H2004 Professeur(s)
Plus en détailUML et les Bases de Données
CNAM UML et les Bases de Données UML et les Bases de Données. Diagramme de classes / diagramme d objets (UML)...2.. Premier niveau de modélisation des données d une application...2.2. Les éléments de modélisation...2.2..
Plus en détailProgrammer en JAVA. par Tama (tama@via.ecp.fr( tama@via.ecp.fr)
Programmer en JAVA par Tama (tama@via.ecp.fr( tama@via.ecp.fr) Plan 1. Présentation de Java 2. Les bases du langage 3. Concepts avancés 4. Documentation 5. Index des mots-clés 6. Les erreurs fréquentes
Plus en détailInitiation à la Programmation en Logique avec SISCtus Prolog
Initiation à la Programmation en Logique avec SISCtus Prolog Identificateurs Ils sont représentés par une suite de caractères alphanumériques commençant par une lettre minuscule (les lettres accentuées
Plus en détailLogiciel Libre Cours 3 Fondements: Génie Logiciel
Logiciel Libre Cours 3 Fondements: Génie Logiciel Stefano Zacchiroli zack@pps.univ-paris-diderot.fr Laboratoire PPS, Université Paris Diderot 2013 2014 URL http://upsilon.cc/zack/teaching/1314/freesoftware/
Plus en détailTable des matières Avant-propos... V Scripting Windows, pour quoi faire?... 1 Dans quel contexte?
Avant-propos... V CHAPITRE 1 Scripting Windows, pour quoi faire?... 1 Dans quel contexte?.................................................. 1 La mauvaise réputation............................................
Plus en détailOCL - Object Constraint Language
OCL - Object Constraint Language Laëtitia Matignon laetitia.matignon@univ-lyon1.fr Département Informatique - Polytech Lyon Université Claude Bernard Lyon 1 2012-2013 Laëtitia Matignon SIMA - OCL - Object
Plus en détailIntroduction à MATLAB R
Introduction à MATLAB R Romain Tavenard 10 septembre 2009 MATLAB R est un environnement de calcul numérique propriétaire orienté vers le calcul matriciel. Il se compose d un langage de programmation, d
Plus en détailPlan du cours : Zippers. Des fonctions sur les listes avec position. Des fonctions sur les listes avec position
Plan du cours : Le problème : naviguer efficacement une structure de données Ce qui ne marche pas Ce qui marche : les de Huet Exemples Comment dériver des pour tout type de données Pour en savoir plus
Plus en détailCours de Génie Logiciel
Cours de Génie Logiciel Sciences-U Lyon Diagrammes UML (2) http://www.rzo.free.fr Pierre PARREND 1 Avril 2005 Sommaire Les Diagrammes UML Diagrammes de Collaboration Diagrammes d'etats-transitions Diagrammes
Plus en détailFormula Negator, Outil de négation de formule.
Formula Negator, Outil de négation de formule. Aymerick Savary 1,2, Mathieu Lassale 1,2, Jean-Louis Lanet 1 et Marc Frappier 2 1 Université de Limoges 2 Université de Sherbrooke Résumé. Cet article présente
Plus en détailExpression des contraintes. OCL : Object C o n t r a i n t L a n g u a g e
P r o b l é m a t i q u e OCL : O b j e c t C o n s t r a i n t L a n g u a g e Le langage de contraintes d UML Les différents diagrammes d UML permettent d exprimer certaines contraintes graphiquement
Plus en détailReconstruction de bâtiments en 3D à partir de nuages de points LIDAR
Reconstruction de bâtiments en 3D à partir de nuages de points LIDAR Mickaël Bergem 25 juin 2014 Maillages et applications 1 Table des matières Introduction 3 1 La modélisation numérique de milieux urbains
Plus en détailÉvaluation et implémentation des langages
Évaluation et implémentation des langages Les langages de programmation et le processus de programmation Critères de conception et d évaluation des langages de programmation Les fondations de l implémentation
Plus en détailLMI 2. Programmation Orientée Objet POO - Cours 9. Said Jabbour. jabbour@cril.univ-artois.fr www.cril.univ-artois.fr/~jabbour
LMI 2 Programmation Orientée Objet POO - Cours 9 Said Jabbour jabbour@cril.univ-artois.fr www.cril.univ-artois.fr/~jabbour CRIL UMR CNRS 8188 Faculté des Sciences - Univ. Artois Février 2011 Les collections
Plus en détailTP3 : Manipulation et implantation de systèmes de fichiers 1
École Normale Supérieure Systèmes et réseaux Année 2012-2013 TP3 : Manipulation et implantation de systèmes de fichiers 1 1 Répertoire de travail courant Le but de l exercice est d écrire une commande
Plus en détailLangage SQL : créer et interroger une base
Langage SQL : créer et interroger une base Dans ce chapitre, nous revenons sur les principales requêtes de création de table et d accès aux données. Nous verrons aussi quelques fonctions d agrégation (MAX,
Plus en détailTP1 : Initiation à Java et Eclipse
TP1 : Initiation à Java et Eclipse 1 TP1 : Initiation à Java et Eclipse Systèmes d Exploitation Avancés I. Objectifs du TP Ce TP est une introduction au langage Java. Il vous permettra de comprendre les
Plus en détailC++ COURS N 2 : CLASSES, DONNÉES ET FONCTIONS MEMBRES Classes et objets en C++ Membres d'une classe Spécification d'une classe Codage du comportement
C++ COURS N 2 : CLASSES, DONNÉES ET FONCTIONS MEMBRES Classes et objets en C++ Membres d'une classe Spécification d'une classe Codage du comportement des objets d'une classe Utilisation d'une classe Droit
Plus en détailMapReduce. Malo Jaffré, Pablo Rauzy. 16 avril 2010 ENS. Malo Jaffré, Pablo Rauzy (ENS) MapReduce 16 avril 2010 1 / 15
MapReduce Malo Jaffré, Pablo Rauzy ENS 16 avril 2010 Malo Jaffré, Pablo Rauzy (ENS) MapReduce 16 avril 2010 1 / 15 Qu est ce que c est? Conceptuellement Données MapReduce est un framework de calcul distribué
Plus en détailTP 1. Prise en main du langage Python
TP. Prise en main du langage Python Cette année nous travaillerons avec le langage Python version 3. ; nous utiliserons l environnement de développement IDLE. Étape 0. Dans votre espace personnel, créer
Plus en détailTable des matières PRESENTATION DU LANGAGE DS2 ET DE SES APPLICATIONS. Introduction
PRESENTATION DU LANGAGE DS2 ET DE SES APPLICATIONS Depuis SAS 9.2 TS2M3, SAS propose un nouveau langage de programmation permettant de créer et gérer des tables SAS : le DS2 («Data Step 2»). Ces nouveautés
Plus en détailObjets et Programmation. origine des langages orientés-objet
Objets et Programmation origine des langages orientés-objet modularité, encapsulation objets, classes, messages exemples en Java héritage, liaison dynamique G. Falquet, Th. Estier CUI Université de Genève
Plus en détailGénie Logiciel avec Ada. 4 février 2013
Génie Logiciel 4 février 2013 Plan I. Généralités II. Structures linéaires III. Exceptions IV. Structures arborescentes V. Dictionnaires I. Principes II. Notions propres à la POO I. Principes Chapitre
Plus en détailHaka : un langage orienté réseaux et sécurité
Haka : un langage orienté réseaux et sécurité Kevin Denis, Paul Fariello, Pierre Sylvain Desse et Mehdi Talbi kdenis@arkoon.net pfariello@arkoon.net psdesse@arkoon.net mtalbi@arkoon.net Arkoon Network
Plus en détailCours intensif Java. 1er cours: de C à Java. Enrica DUCHI LIAFA, Paris 7. Septembre 2009. Enrica.Duchi@liafa.jussieu.fr
. Cours intensif Java 1er cours: de C à Java Septembre 2009 Enrica DUCHI LIAFA, Paris 7 Enrica.Duchi@liafa.jussieu.fr LANGAGES DE PROGRAMMATION Pour exécuter un algorithme sur un ordinateur il faut le
Plus en détailCours d introduction à l informatique. Partie 2 : Comment écrire un algorithme? Qu est-ce qu une variable? Expressions et instructions
Cours d introduction à l informatique Partie 2 : Comment écrire un algorithme? Qu est-ce qu une variable? Expressions et instructions Qu est-ce qu un Une recette de cuisine algorithme? Protocole expérimental
Plus en détailAlgorithmique et Programmation, IMA
Algorithmique et Programmation, IMA Cours 2 : C Premier Niveau / Algorithmique Université Lille 1 - Polytech Lille Notations, identificateurs Variables et Types de base Expressions Constantes Instructions
Plus en détailProjet Active Object
Projet Active Object TAO Livrable de conception et validation Romain GAIDIER Enseignant : M. Noël PLOUZEAU, ISTIC / IRISA Pierre-François LEFRANC Master 2 Informatique parcours MIAGE Méthodes Informatiques
Plus en détailProjet d informatique M1BI : Compression et décompression de texte. 1 Généralités sur la compression/décompression de texte
Projet d informatique M1BI : Compression et décompression de texte Le but de ce projet est de coder un programme réalisant de la compression et décompression de texte. On se proposera de coder deux algorithmes
Plus en détailManuel d utilisation 26 juin 2011. 1 Tâche à effectuer : écrire un algorithme 2
éducalgo Manuel d utilisation 26 juin 2011 Table des matières 1 Tâche à effectuer : écrire un algorithme 2 2 Comment écrire un algorithme? 3 2.1 Avec quoi écrit-on? Avec les boutons d écriture........
Plus en détailUtilisation des tableaux sémantiques dans les logiques de description
Utilisation des tableaux sémantiques dans les logiques de description IFT6281 Web Sémantique Jacques Bergeron Département d informatique et de recherche opérationnelle Université de Montréal bergerja@iro.umontreal.ca
Plus en détailPour signifier qu'une classe fille hérite d'une classe mère, on utilise le mot clé extends class fille extends mère
L'héritage et le polymorphisme en Java Pour signifier qu'une classe fille hérite d'une classe mère, on utilise le mot clé extends class fille extends mère En java, toutes les classes sont dérivée de la
Plus en détailBases de programmation. Cours 5. Structurer les données
Bases de programmation. Cours 5. Structurer les données Pierre Boudes 1 er décembre 2014 This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License. Types char et
Plus en détailChapitre 2 Le problème de l unicité des solutions
Université Joseph Fourier UE MAT 127 Mathématiques année 2011-2012 Chapitre 2 Le problème de l unicité des solutions Ce que nous verrons dans ce chapitre : un exemple d équation différentielle y = f(y)
Plus en détailHigh Performance by Exploiting Information Locality through Reverse Computing. Mouad Bahi
Thèse High Performance by Exploiting Information Locality through Reverse Computing Présentée et soutenue publiquement le 21 décembre 2011 par Mouad Bahi pour l obtention du Doctorat de l université Paris-Sud
Plus en détailLangage et Concepts de ProgrammationOrientée-Objet 1 / 40
Déroulement du cours Introduction Concepts Java Remarques Langage et Concepts de Programmation Orientée-Objet Gauthier Picard École Nationale Supérieure des Mines de Saint-Étienne gauthier.picard@emse.fr
Plus en détaildonnées en connaissance et en actions?
1 Partie 2 : Présentation de la plateforme SPSS Modeler : Comment transformer vos données en connaissance et en actions? SPSS Modeler : l atelier de data mining Large gamme de techniques d analyse (algorithmes)
Plus en détailProjet 2. Gestion des services enseignants CENTRE D ENSEIGNEMENT ET DE RECHERCHE EN INFORMATIQUE. G r o u p e :
CENTRE D ENSEIGNEMENT ET DE RECHERCHE EN INFORMATIQUE Projet 2 Gestion des services enseignants G r o u p e : B E L G H I T Y a s m i n e S A N C H E Z - D U B R O N T Y u r i f e r M O N T A Z E R S i
Plus en détailUniversité de Bangui. Modélisons en UML
Université de Bangui CRM Modélisons en UML Ce cours a été possible grâce à l initiative d Apollinaire MOLAYE qui m a contacté pour vous faire bénéficier de mes connaissances en nouvelles technologies et
Plus en détailJava 1.5 : principales nouveautés
Cours 6 - TEP - UPMC - 2008/2009 p. 1/34 Java 1.5 : principales nouveautés classes paramétrées : generics encapsulation des valeurs de types primitifs : auto[un]boxing itération sur les boucles types énumérés
Plus en détailINF2015 Développement de logiciels dans un environnement Agile. Examen intra 20 février 2014 17:30 à 20:30
Examen intra 20 février 2014 17:30 à 20:30 Nom, prénom : Code permanent : Répondez directement sur le questionnaire. Question #1 5% Quelle influence peut avoir le typage dynamique sur la maintenabilité
Plus en détailINF 232: Langages et Automates. Travaux Dirigés. Université Joseph Fourier, Université Grenoble 1 Licence Sciences et Technologies
INF 232: Langages et Automates Travaux Dirigés Université Joseph Fourier, Université Grenoble 1 Licence Sciences et Technologies Année Académique 2013-2014 Année Académique 2013-2014 UNIVERSITÉ JOSEPH
Plus en détailAutomatisation de l administration système
Automatisation de l administration système Plan Problèmatique : trop de systèmes, trop de solutions Typage des solutions Puppet : gestion de configuration de systèmes Capistrano : déploiement d applications
Plus en détailInitiation à l algorithmique
Informatique S1 Initiation à l algorithmique procédures et fonctions 2. Appel d une fonction Jacques TISSEAU Ecole Nationale d Ingénieurs de Brest Technopôle Brest-Iroise CS 73862-29238 Brest cedex 3 -
Plus en détailUML (Diagramme de classes) Unified Modeling Language
UML (Diagramme de classes) Unified Modeling Language Sommaire Introduction Objectifs Diagramme de classes Classe (Nom, attribut, opération) Visibilité et portée des constituants d une classe Association
Plus en détailPlateforme PAYZEN. Définition de Web-services
Plateforme PAYZEN Définition de Web-services Ordre de paiement Version 1.1 Rédaction, Vérification, Approbation Rédaction Vérification Approbation Nom Date/Visa Nom Date/Visa Nom Date/Visa Lyra-Network
Plus en détailUne introduction à Java
Une introduction à Java IFT 287 (Semaine 1) UNIVERSITÉ DE SHERBROOKE 1 Java - Historique Développé par Sun Microsystems en 1994 Inventeur James Gosling (canadien!) Objectif langage sûr (fortement typé)
Plus en détailSÉCURITÉ DES APPLICATIONS WEB LA SOLUTION D ANALYSE IDÉALE POUR LES APPLICATIONS WEB
SWAT BROCHURE SÉCURITÉ DES APPLICATIONS WEB La sécurité des applications Web s est avérée être un énorme défi pour les entreprises ces dernières années, très peu de solutions appropriées étant disponibles
Plus en détailARBRES BINAIRES DE RECHERCHE
ARBRES BINAIRES DE RECHERCHE Table de symboles Recherche : opération fondamentale données : éléments avec clés Type abstrait d une table de symboles (symbol table) ou dictionnaire Objets : ensembles d
Plus en détailIFT2255 : Génie logiciel
IFT2255 : Génie logiciel Chapitre 6 - Analyse orientée objets Section 1. Introduction à UML Julie Vachon et Houari Sahraoui 6.1. Introduction à UML 1. Vers une approche orientée objet 2. Introduction ti
Plus en détailLicence Bio Informatique Année 2004-2005. Premiers pas. Exercice 1 Hello World parce qu il faut bien commencer par quelque chose...
Université Paris 7 Programmation Objet Licence Bio Informatique Année 2004-2005 TD n 1 - Correction Premiers pas Exercice 1 Hello World parce qu il faut bien commencer par quelque chose... 1. Enregistrez
Plus en détailBases Java - Eclipse / Netbeans
Institut Galilée PDJ Année 2014-2015 Master 1 Environnements Java T.P. 1 Bases Java - Eclipse / Netbeans Il existe plusieurs environnements Java. Il est ESSENTIEL d utiliser la bonne version, et un environnement
Plus en détailLa plate-forme DIMA. Master 1 IMA COLI23 - Université de La Rochelle
La plate-forme DIMA Master 1 IMA COLI23 - Université de La Rochelle DIMA Bref aperçu Qu'est-ce? Acronyme de «Développement et Implémentation de Systèmes Multi-Agents» Initié par Zahia Guessoum et Jean-Pierre
Plus en détailConventions d écriture et outils de mise au point
Logiciel de base Première année par alternance Responsable : Christophe Rippert Christophe.Rippert@Grenoble-INP.fr Introduction Conventions d écriture et outils de mise au point On va utiliser dans cette
Plus en détailPlan du cours. Historique du langage http://www.oracle.com/technetwork/java/index.html. Nouveautés de Java 7
Université Lumière Lyon 2 Faculté de Sciences Economiques et Gestion KHARKIV National University of Economic Introduction au Langage Java Master Informatique 1 ère année Julien Velcin http://mediamining.univ-lyon2.fr/velcin
Plus en détailAlgorithmique et programmation : les bases (VBA) Corrigé
PAD INPT ALGORITHMIQUE ET PROGRAMMATION 1 Cours VBA, Semaine 1 mai juin 2006 Corrigé Résumé Ce document décrit l écriture dans le langage VBA des éléments vus en algorithmique. Table des matières 1 Pourquoi
Plus en détailMODELISATION UN ATELIER DE MODELISATION «RATIONAL ROSE»
MODELISATION UN ATELIER DE MODELISATION «RATIONAL ROSE» Du cours Modélisation Semi -Formelle de Système d Information Du Professeur Jean-Pierre GIRAUDIN Décembre. 2002 1 Table de matière Partie 1...2 1.1
Plus en détailRappel. Analyse de Données Structurées - Cours 12. Un langage avec des déclaration locales. Exemple d'un programme
Rappel Ralf Treinen Université Paris Diderot UFR Informatique Laboratoire Preuves, Programmes et Systèmes treinen@pps.univ-paris-diderot.fr 6 mai 2015 Jusqu'à maintenant : un petit langage de programmation
Plus en détailmodules & compilation
Programmation fonctionnelle avec OCaml 3ème séance, 19 mars 2015 modules & compilation samuel.hornus@inria.fr http ://www.loria.fr/ shornus/ocaml/ Modules Un module regroupe un ensemble de définitions
Plus en détailUEO11 COURS/TD 1. nombres entiers et réels codés en mémoire centrale. Caractères alphabétiques et caractères spéciaux.
UEO11 COURS/TD 1 Contenu du semestre Cours et TDs sont intégrés L objectif de ce cours équivalent a 6h de cours, 10h de TD et 8h de TP est le suivant : - initiation à l algorithmique - notions de bases
Plus en détailProgrammation Orientée Objet
Université de Pau et des Pays de l Adour Institut Universitaire de Technologie des Pays de l Adour Département Réseaux et Télécommunications 371, rue du Ruisseau BP 201 40004 Mont-de-Marsan Cedex tél :
Plus en détailAlgorithmique des Systèmes Répartis Protocoles de Communications
Algorithmique des Systèmes Répartis Protocoles de Communications Master Informatique Dominique Méry Université de Lorraine 1 er avril 2014 1 / 70 Plan Communications entre processus Observation et modélisation
Plus en détailLes diagrammes de modélisation
L approche Orientée Objet et UML 1 Plan du cours Introduction au Génie Logiciel L approche Orientée Objet et Notation UML Les diagrammes de modélisation Relations entre les différents diagrammes De l analyse
Plus en détailLES TYPES DE DONNÉES DU LANGAGE PASCAL
LES TYPES DE DONNÉES DU LANGAGE PASCAL 75 LES TYPES DE DONNÉES DU LANGAGE PASCAL CHAPITRE 4 OBJECTIFS PRÉSENTER LES NOTIONS D ÉTIQUETTE, DE CONS- TANTE ET DE IABLE DANS LE CONTEXTE DU LAN- GAGE PASCAL.
Plus en détailRapport de Synthèse. Création d un Générateur de modèle PADL pour le langage C++ Sébastien Colladon
L Y O N Département Informatique Année 2011/2012 Rapport de Synthèse Création d un Générateur de modèle PADL pour le langage C++ Sébastien Colladon Laboratoire Ptidej de L Ecole Polytechnique de Montréal
Plus en détailGOL502 Industries de services
GOL502 Industries de services Conception d un service Partie IIb Version 2013 Introduction Conception d un service partie IIb Nous verrons dans ce chapitre Modélisation d un service; Langage de modélisation
Plus en détailCours de Systèmes d Exploitation
Licence d informatique Synchronisation et Communication inter-processus Hafid Bourzoufi Université de Valenciennes - ISTV Introduction Les processus concurrents s exécutant dans le système d exploitation
Plus en détailEPREUVE OPTIONNELLE d INFORMATIQUE CORRIGE
EPREUVE OPTIONNELLE d INFORMATIQUE CORRIGE QCM Remarque : - A une question correspond au moins 1 réponse juste - Cocher la ou les bonnes réponses Barème : - Une bonne réponse = +1 - Pas de réponse = 0
Plus en détailTD3: tableaux avancées, première classe et chaînes
TD3: tableaux avancées, première classe et chaînes de caractères 1 Lestableaux 1.1 Élémentsthéoriques Déclaration des tableaux Pour la déclaration des tableaux, deux notations sont possibles. La première
Plus en détailProgrammation Objet - Cours II
Programmation Objet - Cours II - Exercices - Page 1 Programmation Objet - Cours II Exercices Auteur : E.Thirion - Dernière mise à jour : 05/07/2015 Les exercices suivants sont en majorité des projets à
Plus en détailMandataires, caches et filtres
Mandataires, caches et filtres Pascal AUBRY IFSIC - Université de Rennes 1 Pascal.Aubry@univ-rennes1.fr Plan : mandataires caches filtrage serveur de proxy exemple de mise en œuvre Mandataire (proxy) Mandataire
Plus en détailLangage SQL (1) 4 septembre 2007. IUT Orléans. Introduction Le langage SQL : données Le langage SQL : requêtes
Langage SQL (1) Sébastien Limet Denys Duchier IUT Orléans 4 septembre 2007 Notions de base qu est-ce qu une base de données? SGBD différents type de bases de données quelques systèmes existants Définition
Plus en détailPrésentation du PL/SQL
I Présentation du PL/ Copyright Oracle Corporation, 1998. All rights reserved. Objectifs du Cours A la fin de ce chapitre, vous saurez : Décrire l intéret du PL/ Décrire l utilisation du PL/ pour le développeur
Plus en détailGuide No.2 de la Recommandation Rec (2009).. du Comité des Ministres aux États membres sur la démocratie électronique
DIRECTION GENERALE DES AFFAIRES POLITIQUES DIRECTION DES INSTITUTIONS DEMOCRATIQUES Projet «BONNE GOUVERNANCE DANS LA SOCIETE DE L INFORMATION» CAHDE (2009) 2F Strasbourg, 20 janvier 2009 Guide No.2 de
Plus en détailPoker. A rendre pour le 25 avril
Poker A rendre pour le 25 avril 0 Avant propos 0.1 Notation Les parties sans * sont obligatoires (ne rendez pas un projet qui ne contient pas toutes les fonctions sans *). Celles avec (*) sont moins faciles
Plus en détaillength : A N add : Z Z Z (n 1, n 2 ) n 1 + n 2
1 Univ. Lille1 - Licence info 3ème année 2013-2014 Expression Logique et Fonctionnelle... Évidemment Cours n o 1 : Introduction à la programmation fonctionnelle 1 Introduction La programmation fonctionnelle
Plus en détailStructuration des décisions de jurisprudence basée sur une ontologie juridique en langue arabe
Structuration des décisions de jurisprudence basée sur une ontologie juridique en langue arabe Karima Dhouib, Sylvie Després Faiez Gargouri ISET - Sfax Tunisie, BP : 88A Elbustan ; Sfax karima.dhouib@isets.rnu.tn,
Plus en détailas Architecture des Systèmes d Information
Plan Plan Programmation - Introduction - Nicolas Malandain March 14, 2005 Introduction à Java 1 Introduction Présentation Caractéristiques Le langage Java 2 Types et Variables Types simples Types complexes
Plus en détailCours d Algorithmique-Programmation 2 e partie (IAP2): programmation 24 octobre 2007impérative 1 / 44 et. structures de données simples
Cours d Algorithmique-Programmation 2 e partie (IAP2): programmation impérative et structures de données simples Introduction au langage C Sandrine Blazy - 1ère année 24 octobre 2007 Cours d Algorithmique-Programmation
Plus en détailCréation et Gestion des tables
Création et Gestion des tables Version 1.0 Z Grégory CASANOVA 2 Sommaire 1 Introduction... 3 2 Pré-requis... 4 3 Les tables... 5 3.1 Les types de données... 5 3.1.1 Les types de données Sql Server... 5
Plus en détailProblèmes de Mathématiques Filtres et ultrafiltres
Énoncé Soit E un ensemble non vide. On dit qu un sous-ensemble F de P(E) est un filtre sur E si (P 0 ) F. (P 1 ) (X, Y ) F 2, X Y F. (P 2 ) X F, Y P(E) : X Y Y F. (P 3 ) / F. Première Partie 1. Que dire
Plus en détailLes chaînes de caractères
Les chaînes de caractères Dans un programme informatique, les chaînes de caractères servent à stocker les informations non numériques comme par exemple une liste de nom de personne ou des adresses. Il
Plus en détail