Langage de Programmation 2 (LP2)
|
|
|
- Julie Larivière
- il y a 6 ans
- Total affichages :
Transcription
1 Langage de Programmation 2 (LP2) RICM3 Cours 5 : Polymorphisme, Typage, Complexité Pascal Lafourcade Polytech / 76
2 La dernière fois Preuves Foncteurs Modules 2 / 76
3 Plan Preuve Fonction d ordre supérieur Type Option Généralités sur le Typage Typage du let et let rec Polymorphisme Complexité : Substitution Complements OCaml Conclusion 3 / 76
4 Preuve Fonction d ordre supérieur Type Option Généralités sur le Typage Typage du let et let rec Polymorphisme Complexité : Substitution Complements OCaml Conclusion
5 Preuve x a, mem x a appart x a let rec mem x = function F -> false N(g, y, d) -> x=y (if x<y then mem x g else mem x d) let rec appart x a = match a with F -> false N(g, y, d) -> appart x g x=y appart x d Induction structurelle sur a, puis par cas sur x = y, x < y et (x = y x < y). Complétude : x a, appart x a mem x a Démonstration analogue, mais on utilise de plus le fait que (x = y x < y) y < x. 6 / 76
6 Preuve Preuve par induction x a, mem x a appart x a Soit e un entier. let rec mem x = function F -> false N(g, y, d) -> x=y (if x<y then mem x g else mem x d) let rec appart x a = match a with F -> false N(g, y, d) -> appart x g x=y appart x d Cas de base : Montrons appart e F mem e F. appart e F = false = mem e F 8 / 76
7 Preuve Preuve par induction x a, mem x a appart x a Soient g et d deux ABR tels que appart e g mem e g et appart e d mem e d. Soit n un entier. Rappel : appart e N(g, n, d) = n = e (appart e g) (appart e d) mem e N(g, n, d) = if e < n then(appart e g)else n = e (appart e d) appart e N(g, n, d) mem e N(g, n, d) par double implication. Supposons que appart e N(g, n, d). Si n = e alors mem e N(g, n, d). Si appart e g alors d après la définition d ABR, e < n et donc mem e N(g, n, d) également. Si appart e d alors d après la définition d ABR, e > n et donc mem e N(g, n, d). 10 / 76
8 Preuve Preuve par induction x a, mem x a appart x a appart e N(g, n, d) mem e N(g, n, d) par double implication. Supposons que mem e N(g, n, d). On a e < n ou e = n ou e > n : Si e < n alors appart e g et donc appart e N(g, n, d). Si e = n alors appart e N(g, n, d). Enfin, si e > n alors appart e d et donc appart e N(g, n, d). D ou le resultat. 12 / 76
9 Preuve Fonction d ordre supérieur Type Option Généralités sur le Typage Typage du let et let rec Polymorphisme Complexité : Substitution Complements OCaml Conclusion
10 Fonction d ordre supérieur iter Écrire une fonction qui itére un nombre fixé de fois une autre fonction. Solution 14 / 76
11 Fonction d ordre supérieur iter Écrire une fonction qui itére un nombre fixé de fois une autre fonction. Solution # let rec iter f n = fun x -> if n = 0 then x else f (( iter f (n-1)) x) ; ; val iter : ( a -> a) -> int -> a -> a = <fun> # (iter (fun x -> x + 2 ) 10 ) 22 ; ; 14 / 76
12 Fonction d ordre supérieur iter Écrire une fonction qui itére un nombre fixé de fois une autre fonction. Solution # let rec iter f n = fun x -> if n = 0 then x else f (( iter f (n-1)) x) ; ; val iter : ( a -> a) -> int -> a -> a = <fun> # (iter (fun x -> x + 2 ) 10 ) 22 ; ; - : int = / 76
13 Preuve Fonction d ordre supérieur Type Option Généralités sur le Typage Typage du let et let rec Polymorphisme Complexité : Substitution Complements OCaml Conclusion
14 Type Option Type OPTION type a option = None Some of a Étend un type avec une valeur None. 17 / 76
15 Type Option Type OPTION Application let depile l = match l with [] -> failwith "Pile Vide" e::r -> e ;; val depile : int list -> int = <fun> 19 / 76
16 Type Option Type OPTION Application let depile l = match l with [] -> failwith "Pile Vide" e::r -> e ;; val depile : int list -> int = <fun> Solution : Depiler générique 19 / 76
17 Type Option Type OPTION Application let depile l = match l with [] -> failwith "Pile Vide" e::r -> e ;; val depile : int list -> int = <fun> Solution : Depiler générique let depile l = match l with [] -> None e : :r -> Some e ; ; val depile : a list -> a option = <fun> let x = depile [] in match x with None -> failwith "Error" Some e -> e ; ; 19 / 76
18 Preuve Fonction d ordre supérieur Type Option Généralités sur le Typage Typage du let et let rec Polymorphisme Complexité : Substitution Complements OCaml Conclusion
19 Généralités sur le Typage Système de types Types de données simples : numériques, booléens, chaînes structurés : produits (n-uplets, records), sommes (choix) Types fonctionnels fonction = valeur ordinaire toutes combinaisons permises, ex. listes de fonctions 21 / 76
20 Généralités sur le Typage Types Les types sont inférés automatiquement Pour les données Types de base : int, float, char, string, bool, unit Types construits : produits (juxtaposition) et sommes (choix) Pour les fonctions Exemple : succ int int Types polymorphes (généricité ADA) Exemple : test d égalité (=) α α bool 22 / 76
21 Généralités sur le Typage Typage dans un environnement Γ expression : type Γ environnement de typage = liste d associations x t, où x est un nom et t un type Exemples nbr int nbr + 4 : int nbr int; b1 bool nbr + 4 : int nbr int; b1 bool; nbr float nbr : float 23 / 76
22 Généralités sur le Typage Règles initiales de typage Constantes littérales Γ 0 : int Et similairement pour..., 2, 1, 1, 2,..., les booléens, les flottants, les caractères, les chaînes, etc. Gestion de l environnement de typage Γ; x t x : t Γ x : t x y Γ; y u x : t NB. Environnement parcouru à partir de la droite 24 / 76
23 Généralités sur le Typage Expression conditionnelle Expression = valeur (exemple : un entier) if B then E 1 else E 2 Règle de typage Γ B : bool Γ E 1 : t Γ E 2 : t Γ (if B then E 1 else E 2 ) : t Remarques Type calculé à la fois pour E 1 et E 2 ( valeur) Différence entre le typage statique et l évaluation dynamique : système de types décidable 25 / 76
24 Généralités sur le Typage Types nommés type t = T Où t est un nom et T une expression de type Exemples type nom = string type test_int = int bool On a un environnement statique supplémentaire d associations t T Pour alléger, cet environnement est omis dans la suite, on écrira simplement t déf == T 26 / 76
25 Généralités sur le Typage Typage des couples et n-uplets Construction Γ A : t Γ B : u Γ (A, B) : t u Similairement pour des n-uplets Décomposition Par filtrage, cf. plus bas. 27 / 76
26 Généralités sur le Typage Enregistrements = produits avec champs nommés Autres langages : record ADA, struct C Il faut nommer le type type r = {c 1 : T 1 ;... c n : T n } Accès aux champs (mathématiquement : projections) en notation pointée Exemples type ic = { en : int ; ca : char } exemple de valeur : { en = 3 ; ca = z } let cpl = { en = 3 ; ca = z } in succ cpl.en 4 type fa = { fct : int int ; arg : int } let cp = { fct = fun x x + 1 ; arg = 7 } in cp.fct cp.arg 8 28 / 76
27 Généralités sur le Typage Typage des enregistrements On suppose r déf == {c 1 : T 1 ;... c n : T n } Construction Γ E 1 : T 1... Γ E n : T n Γ {c 1 = E 1 ;... c n = E n } : r Décomposition Pour tout i, 1 i n, Ou par filtrage, cf. plus bas. Γ E : r Γ E.c i : T i 29 / 76
28 Généralités sur le Typage Fonctions A, B et E sont des expressions Notation mathématique : λx.e Notation Ocaml : fun x E Règles de typage Γ A : t u Γ B : t Γ A B : u Γ, x t E : u Γ fun x E : t u 30 / 76
29 Généralités sur le Typage Typage L environnement Γ 0 initialement chargé (appelé Pervasives) contient : (+) int int int ; ( ) int int int ; etc. (+.) float float float ; (.) float float float ; (&&) bool bool bool ; ( ) bool bool bool ; voir manuel Γ 0 (+) : int int int Γ 0 3 : int Γ 0 (+) 3 : int int Γ 0 2 : int Γ 0 (+) 3 2 : int 31 / 76
30 Généralités sur le Typage Exemple Vérifier que : Γ 0 Γ, x t E : u Γ fun x E : t u Γ A : t u Γ B : t Γ A B : u fun x x + 1 : int int 32 / 76
31 Généralités sur le Typage Exemple Vérifier que : Γ 0 Γ, x t E : u Γ fun x E : t u Γ A : t u Γ B : t Γ A B : u fun x x + 1 : int int Γ 1 + : int int int Γ 1 1 : int Γ 1 +1 : int int Γ 1 x : int Γ 1 = Γ 0, x int x + 1 : int fun x x + 1 : int int Γ 0 32 / 76
32 Généralités sur le Typage Exercice Sachant que l environnement Γ 0 contient succ int int (et aucun autre couple succ t) vérifier que Γ 0 fun n succ (succ n) : int int Notation (pour raison de place) s déf Γ 1 == succ déf == Γ 0, n int 33 / 76
33 Généralités sur le Typage Exercice Sachant que l environnement Γ 0 contient succ int int (et aucun autre couple succ t) vérifier que Γ 0 fun n succ (succ n) : int int Notation (pour raison de place) s déf Γ 1 == succ déf == Γ 0, n int Γ 1 Γ 1 s : int int Γ 0, n int n : int s : int int Γ 0, n int s n : int Γ 1 = Γ 0, n int s (s n) : int fun n s (s n) : int int Γ 0 33 / 76
34 Généralités sur le Typage Tableaux Mathématiquement :fonctions à domaine fini [0... n 1] Example [ true; false; true; true; false ] correspondrait à une fonction de type [0... 4] bool En réalité [ true; false; true; true; false ] : bool array [0... 4] n est pas un type Soit T un tableau d éléments de type t, i.e. T : t array Alors fun i T.(i) : int t Mais définie seulement sur [0... Array.lengthT 1] 34 / 76
35 Généralités sur le Typage Règles de typage pour les tableaux i, 0 i < n Γ A i : t Γ [ A 0 ;... ; A n 1 ] : t array Γ A : t array Γ B : int Γ A.(B) : t NB. Le typage ne vérifie pas les bornes (problème indécidable) 35 / 76
36 Preuve Fonction d ordre supérieur Type Option Généralités sur le Typage Typage du let et let rec Polymorphisme Complexité : Substitution Complements OCaml Conclusion
37 Typage du let et let rec Typage du let Γ A : t Γ, x t B : u Γ let x = A in B : u 37 / 76
38 Typage du let et let rec Typage du let Exemple # let x = 5 in x ; ; - : int = 5 Γ A : t Γ, x t B : u Γ let x = A in B : u Γ 5 : int Γ, x int x : int Γ let x = 5 in x : int 37 / 76
39 Typage du let et let rec Exercice Vérifier le type de : Γ A : t Γ, x t B : u Γ let x = A in B : u # let succ = fun x -> x + 1 in succ 1 ; ; - : int = 2 val x : int -> int = <fun> 38 / 76
40 Typage du let et let rec Exercice Vérifier le type de : Γ A : t Γ, x t B : u Γ let x = A in B : u # let succ = fun x -> x + 1 in succ 1 ; ; - : int = 2 val x : int -> int = <fun>. Γ fun x x + 1 : int int Γ 0 succ : int int Γ 0 1 : int Γ 0 = Γ, succ int int succ 1 : int Γ let succ = fun x x + 1 in succ 1 : int 38 / 76
41 Typage du let et let rec Typage du let rec Γ, x t A : t Γ, x t B : u Γ let rec x = A in B : u 39 / 76
42 Typage du let et let rec Typage du let rec Γ, x t A : t Γ, x t B : u Γ let rec x = A in B : u Exemple : fact I # let rec fact n = if n = 0 then 1 else n* (fact (n-1)) ; ; val fact : int -> int = <fun> Au tableau en utilisant Γ, x t A : t Γ, x t B : u Γ let rec x = A in B : u 39 / 76
43 Preuve Fonction d ordre supérieur Type Option Généralités sur le Typage Typage du let et let rec Polymorphisme Complexité : Substitution Complements OCaml Conclusion
44 Polymorphisme Le polymorphisme : définitions Définitions Étymologiquement : 41 / 76
45 Polymorphisme Le polymorphisme : définitions Définitions Étymologiquement : plusieurs formes 41 / 76
46 Polymorphisme Le polymorphisme : définitions Définitions Étymologiquement : plusieurs formes En informatique : 41 / 76
47 Polymorphisme Le polymorphisme : définitions Définitions Étymologiquement : plusieurs formes En informatique : capacité d une fonction à «s adapter» à des arguments de type différent 41 / 76
48 Polymorphisme Le polymorphisme : définitions Définitions Étymologiquement : plusieurs formes En informatique : capacité d une fonction à «s adapter» à des arguments de type différent Deux espèces (hors langages à objets) : polymorphisme ad-hoc ex : + sur les entiers, les flottants, les chaîne... dans chaque type, le sens (le code exécuté) est différent 41 / 76
49 Polymorphisme Le polymorphisme : définitions Définitions Étymologiquement : plusieurs formes En informatique : capacité d une fonction à «s adapter» à des arguments de type différent Deux espèces (hors langages à objets) : polymorphisme ad-hoc ex : + sur les entiers, les flottants, les chaîne... dans chaque type, le sens (le code exécuté) est différent polymorphisme paramétrique ex sur les listes d entiers, de flottants, de chaînes... le code exécuté est uniformément le même 41 / 76
50 Polymorphisme Exemple basique * Fonction identité type : let id = fun x x 42 / 76
51 Polymorphisme Exemple basique * Fonction identité type : α α let id = fun x x Application : à des entiers : id 3 à des arbres : id (N (N (F, 7, F), 2, N (F, 5, F))) à des fonctions : id (fun n (n +3)) à elle-même : id id, id id 3.14 [ hors théorie des ensembles] 42 / 76
52 Polymorphisme Autres exemples * Paire # let pairing x y = (x,y) ; ; type : 43 / 76
53 Polymorphisme Autres exemples * Paire # let pairing x y = (x,y) ; ; type : val id : a -> b -> a * b = <fun> 43 / 76
54 Polymorphisme Autres exemples * Paire # let pairing x y = (x,y) ; ; type : val id : a -> b -> a * b = <fun> Compositions de fonctions let comp f g = fun x g (f x) type : 43 / 76
55 Polymorphisme Autres exemples * Paire # let pairing x y = (x,y) ; ; type : val id : a -> b -> a * b = <fun> Compositions de fonctions let comp f g = fun x g (f x) type : (β γ) (α β) (α γ) 43 / 76
56 Polymorphisme Autres exemples * Paire # let pairing x y = (x,y) ; ; type : val id : a -> b -> a * b = <fun> Compositions de fonctions let comp f g = fun x g (f x) type : (β γ) (α β) (α γ) FAUX 43 / 76
57 Polymorphisme Autres exemples * Paire # let pairing x y = (x,y) ; ; type : val id : a -> b -> a * b = <fun> Compositions de fonctions let comp f g = fun x g (f x) type : (β γ) (α β) (α γ) FAUX type : (α β) (β γ) (α γ) 43 / 76
58 Polymorphisme Autres exemples * Ces fonctions acceptent tous les types possibles... a, b,... sont des variables de types Un type contenant des variables est dit polymorphe Pour tout a, a donne a... a.(a a) 44 / 76
59 Polymorphisme Évaluation de l itération fonctionnelle * Itération d une fonction let rec iter n f = if n = 0 then id else comp f (iter (n 1) f ), type? 45 / 76
60 Polymorphisme Évaluation de l itération fonctionnelle * Itération d une fonction let rec iter n f = if n = 0 then id else comp f (iter (n 1) f ), type? int (α α) (α α) 45 / 76
61 Polymorphisme Évaluation de l itération fonctionnelle * Itération d une fonction let rec iter n f = if n = 0 then id else comp f (iter (n 1) f ), type? int (α α) (α α) let plus3 = (+) 3 iter 2 plus3 comp plus3 (iter 1 plus3) comp plus3 (comp plus3 (iter 0 plus3)) comp plus3 (comp plus3 id) comp plus3 (comp ((+) 3) (fun x x)) comp plus3 (fun y ((+) 3 ((fun x x) y))) comp ((+) 3 (fun y ((+) 3 ((fun x x) y)))) fun z ((+) 3 ((fun y ((+) 3 ((fun x x) y))) z)) Dans un langage avec évaluation du corps de la fonction ( ML, dont Ocaml), réductions supplémentaires : fun z ((+) 3 (fun y ((+) 3 y)) z) 45 / 76
62 Polymorphisme Exemple : pas toujours fonctionnels # [] ; ; - : a list = [] # fun x -> x : : [] ; ; 46 / 76
63 Polymorphisme Exemple : pas toujours fonctionnels # [] ; ; - : a list = [] # fun x -> x : : [] ; ; - : a -> a list = <fun> # fun x -> x + 1 : : [] ; ; - : int -> int list = <fun> 46 / 76
64 Polymorphisme Le polymorphisme dans les données (1) Listes type α liste = Nil Cons of α α liste let rec app l1 l2 = match l1 with Nil l2 Cons (x, l1) Cons (x, app l1 l2) 47 / 76
65 Polymorphisme Le polymorphisme dans les données (2) Application à des entiers : [3 ; 0 ; 8 ] à des arbres : [N (F, 7, F) ; F ; N (F, 5, F)] à des fonctions : [fun n (n +3) ; ( ) 6 ; fact] à des fonctions polymorphes : [ (fun x x) ; (fun x raise Exc) ] à des listes : [[1 ; 2 ; 3 ] ; [1 ; 5 ] ; [] ; [7 ; 6 ; 2 ]]] hors théorie des ensembles Attention à l uniformité! 48 / 76
66 Polymorphisme Le polymorphisme dans les données (3) Type option (en standard) type α option = None Some of α Technique possible pour les fonctions partielles let tete l = match l with Nil None Cons (x, _) Some (x) Type : 49 / 76
67 Polymorphisme Le polymorphisme dans les données (3) Type option (en standard) type α option = None Some of α Technique possible pour les fonctions partielles let tete l = match l with Nil None Cons (x, _) Some (x) Type : tete : α liste α option 49 / 76
68 Polymorphisme Le polymorphisme ad-hoc en Ocaml Sur les opérateurs de comparaison : =, <, <=,... α α bool Disponible sur toutes les structures de données entiers : 14 < 5 +5 ; caractères, booléens, chaînes listes : [3 ; 4 ] < [2 ; 5 ; 7 ] ; arbres 50 / 76
69 Polymorphisme Le polymorphisme ad-hoc en Ocaml Sur les opérateurs de comparaison : =, <, <=,... α α bool Disponible sur toutes les structures de données entiers : 14 < 5 +5 ; caractères, booléens, chaînes listes : [3 ; 4 ] < [2 ; 5 ; 7 ] ; arbres Mais pas sur les types fonctionnels, ex : α α : id = id 50 / 76
70 Polymorphisme Exemple de polymorphisme ad-hoc en Ocaml * type (α, β) abr = F N of (α, β) abr α β (α, β) abr let rec cherche x = function F None N (g, y, v, d) if y = x then Some (v) else if y < x then cherche x g else cherche x d 51 / 76
71 Polymorphisme Exemple de polymorphisme ad-hoc en Ocaml * type (α, β) abr = F N of (α, β) abr α β (α, β) abr let rec cherche x = function F None N (g, y, v, d) if y = x then Some (v) else if y < x then cherche x g else cherche x d type : α (α, β) abr β option 51 / 76
72 Preuve Fonction d ordre supérieur Type Option Généralités sur le Typage Typage du let et let rec Polymorphisme Complexité : Substitution Complements OCaml Conclusion
73 Complexité : Substitution Méthode par Substituion Idée Deviner le résultat Le prouver par induction Ajuster les constantes 54 / 76
74 Complexité : Substitution Méthode par Substituion : Exemple Complexité? T (n) = 4T (n/2) + n 56 / 76
75 Complexité : Substitution Méthode par Substituion : Exemple Complexité? T (n) = O(n 2 ) Plan T (n) = O(n 3 ) 2 essais pour O(n 2 ) T (n) = 4T (n/2) + n 56 / 76
76 Complexité : Substitution Méthode par Substituion : O(n 3 ) PosonsT (n) = O(n 3 ), T (n) = 4T (n/2) + n 58 / 76
77 Complexité : Substitution Méthode par Substituion : O(n 3 ) T (n) = 4T (n/2) + n PosonsT (n) = O(n 3 ), T (k) ck 3 pour k n T (n) 4c( n 2 )3 + n = 1 2 cn3 + n = cn 3 ( 1 2 cn3 n) cn 3 si 1 2 cn3 n 0 Donc c 1 et n 1 58 / 76
78 Complexité : Substitution Méthode par Substituion : O(n 2 ) PosonsT (n) = O(n 2 ), T (n) = 4T (n/2) + n 60 / 76
79 Complexité : Substitution Méthode par Substituion : O(n 2 ) T (n) = 4T (n/2) + n PosonsT (n) = O(n 2 ), T (k) ck 2 pour k n Echec!! T (n) 4c( n 2 )2 + n = cn 2 + n = cn 2 ( n) si n 0 cn 2 60 / 76
80 Complexité : Substitution Méthode par Substituion : O(n 2 ) T (n) = 4T (n/2) + n PosonsT (n) = O(n 2 ), T (k) ck 2 pour k n Echec!! Soyons plus précis T (n) 4c( n 2 )2 + n = cn 2 + n = cn 2 ( n) si n 0 cn 2 60 / 76
81 Complexité : Substitution Méthode par Substituion : O(n 2 ) le retour PosonsT (n) = O(n 2 ), T (n) = 4T (n/2) + n 62 / 76
82 Complexité : Substitution Méthode par Substituion : O(n 2 ) le retour T (n) = 4T (n/2) + n PosonsT (n) = O(n 2 ), T (k) c 1 k 2 c 2 n pour k n Si c 2 1 T (n) 4(c 1 ( n n 2 )2 c 2 2 ) + n = c 1 n 2 + (1 2c 2 )n = c 1 n 2 c 2 n (c 2 1)n si (c 2 1)n 0 c 1 n 2 c 2 n 62 / 76
83 Complexité : Substitution Méthode par Substituion : O(n 2 ) le retour T (n) = 4T (n/2) + n PosonsT (n) = O(n 2 ), T (k) c 1 k 2 c 2 n pour k n T (n) 4(c 1 ( n n 2 )2 c 2 2 ) + n = c 1 n 2 + (1 2c 2 )n = c 1 n 2 c 2 n (c 2 1)n si (c 2 1)n 0 c 1 n 2 c 2 n Si c 2 1 Cas de base : T (1) = O(1) on obtient T (1) c 1 c 2 Si c 2 plus large que c / 76
84 Complexité : Substitution Deux autres méthodes Arbre de récursion Master méthode 63 / 76
85 Preuve Fonction d ordre supérieur Type Option Généralités sur le Typage Typage du let et let rec Polymorphisme Complexité : Substitution Complements OCaml Conclusion
86 Complements OCaml Comparaisons Opérateurs =, <>, <, <=, >=, > Chaque type de base est ordonné abc < bca b <> z 65 / 76
87 Complements OCaml Comparaisons Opérateurs =, <>, <, <=, >=, > Chaque type de base est ordonné abc < bca b <> z Comparsaison sur les valeurs 10+2 < 13 Ocaml = O ˆ caml true <> false 65 / 76
88 Complements OCaml Syntaxe infixe Lorsque l on a, comme pour l addition : une fonction binaire F dont le nom est composé de caractères spéciaux (+,, etc.) deux arguments A et B alors l application de F à A et B peut se noter de manière infixe : A F B Exemples : 3 + 2, Syntaxe préfixe encore possible l écriture préfixe de F est (F ), i.e. (F ) A B est autorisé exemple : (+) / 76
89 Types mutuellement récursifs type arbre = Feuille of int Foret of foret and foret = Fvide F1 of arbre * foret F1 (Feuille (3), F1 (Foret (F1 (Feuille (5), F1 (Feuille (8), Fvide))), Fvide)) F1 Feuille F1 3 Foret Fvide F1 Feuille F1
90 Complements OCaml Tableaux sont des fonctions Mathématiquement fonctions à domaine fini de la forme [0... n 1] Exemple [ true; false; true; true; false ] correspondraità une fonction de type [0... 4] bool En réalité [ true; false; true; true; false ] : bool array [0... 4] n est pas un type Soit T un tableau d éléments de type t, i.e. T : t array Alors fun i T.(i) : int t Mais définie seulement sur [0... Array.lengthT 1] 68 / 76
91 Complements OCaml Avec le package List include List ; ; Append # [42 ;12]@[2 ;3] ; ; - : int list = [42 ;12 ;2 ;3] Head # List.hd [1 ;2 ;3 ;4 ;5] ; ; - : int = 1 Tail List.tl [ Ocaml ; is ; fantastic ] ; ; - : string list = [ is ; fantastic ] 69 / 76
92 Preuve Fonction d ordre supérieur Type Option Généralités sur le Typage Typage du let et let rec Polymorphisme Complexité : Substitution Complements OCaml Conclusion
93 Conclusion Aujourd hui Typage 71 / 76
94 Conclusion Prochaine fois Polymorphisme Inférence de type 72 / 76
95 Conclusion Merci de votre attention. Questions? 73 / 76
length : 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
# 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>
![# 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>](/thumbs/20/394597.jpg "# 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
Cours 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
Recherche 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
Classes 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.
Machines virtuelles fonctionnelles (suite) Compilation ML Java
Machines virtuelles fonctionnelles (suite) Compilation ML Java Cours de Compilation Avancée (MI190) Benjamin Canou Université Pierre et Maire Curie Année 2011/2012 Semaine 3 Machines virtuelles fonctionnelles
1/24. I passer d un problème exprimé en français à la réalisation d un. I expressions arithmétiques. I structures de contrôle (tests, boucles)
1/4 Objectif de ce cours /4 Objectifs de ce cours Introduction au langage C - Cours Girardot/Roelens Septembre 013 Du problème au programme I passer d un problème exprimé en français à la réalisation d
1. Structure d un programme C. 2. Commentaire: /*..texte */ On utilise aussi le commentaire du C++ qui est valable pour C: 3.
1. Structure d un programme C Un programme est un ensemble de fonctions. La fonction "main" constitue le point d entrée pour l exécution. Un exemple simple : #include int main() { printf ( this
Algorithmique 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
Cours 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
Cours 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
Suivant 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
LMI 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
Java Licence Professionnelle CISII, 2009-10
Java Licence Professionnelle CISII, 2009-10 Cours 4 : Programmation structurée (c) http://www.loria.fr/~tabbone/cours.html 1 Principe - Les méthodes sont structurées en blocs par les structures de la programmation
INTRODUCTION A JAVA. Fichier en langage machine Exécutable
INTRODUCTION A JAVA JAVA est un langage orienté-objet pur. Il ressemble beaucoup à C++ au niveau de la syntaxe. En revanche, ces deux langages sont très différents dans leur structure (organisation du
Licence ST Université Claude Bernard Lyon I LIF1 : Algorithmique et Programmation C Bases du langage C 1 Conclusion de la dernière fois Introduction de l algorithmique générale pour permettre de traiter
Gé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
modules & 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
Info0101 Intro. à l'algorithmique et à la programmation. Cours 3. Le langage Java
Info0101 Intro. à l'algorithmique et à la programmation Cours 3 Le langage Java Pierre Delisle, Cyril Rabat et Christophe Jaillet Université de Reims Champagne-Ardenne Département de Mathématiques et Informatique
Initiation à 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
Cours de C++ François Laroussinie. 2 novembre 2005. Dept. d Informatique, ENS de Cachan
Cours de C++ François Laroussinie Dept. d Informatique, ENS de Cachan 2 novembre 2005 Première partie I Introduction Introduction Introduction Algorithme et programmation Algorithme: méthode pour résoudre
Rappel. 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
Structure d un programme et Compilation Notions de classe et d objet Syntaxe
Cours1 Structure d un programme et Compilation Notions de classe et d objet Syntaxe POO 1 Programmation Orientée Objet Un ensemble d objet qui communiquent Pourquoi POO Conception abstraction sur les types
UEO11 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
Présentation du langage et premières fonctions
1 Présentation de l interface logicielle Si les langages de haut niveau sont nombreux, nous allons travaillé cette année avec le langage Python, un langage de programmation très en vue sur internet en
Introduction au langage C
Introduction au langage C Cours 1: Opérations de base et premier programme Alexis Lechervy Alexis Lechervy (UNICAEN) Introduction au langage C 1 / 23 Les premiers pas Sommaire 1 Les premiers pas 2 Les
Cours d initiation à la programmation en C++ Johann Cuenin
Cours d initiation à la programmation en C++ Johann Cuenin 11 octobre 2014 2 Table des matières 1 Introduction 5 2 Bases de la programmation en C++ 7 3 Les types composés 9 3.1 Les tableaux.............................
TP 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
Langage 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
Algorithmique & programmation
Algorithmique & programmation Type structuré Article, Enregistrement, Structure Définition de nouveaux types!! On a vu les types simples "! entier, booléen, caractère, chaîne de caractères!! Comment gérer
INITIATION AU LANGAGE C SUR PIC DE MICROSHIP
COURS PROGRAMMATION INITIATION AU LANGAGE C SUR MICROCONTROLEUR PIC page 1 / 7 INITIATION AU LANGAGE C SUR PIC DE MICROSHIP I. Historique du langage C 1972 : naissance du C dans les laboratoires BELL par
Une 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
Cours d Algorithmique et de Langage C 2005 - v 3.0
Cours d Algorithmique et de Langage C 2005 - v 3.0 Bob CORDEAU cordeau@onera.fr Mesures Physiques IUT d Orsay 15 mai 2006 Avant-propos Avant-propos Ce cours en libre accès repose sur trois partis pris
Correction Code nécessaire à la compilation : let bs ="\\" let nl = "\n" ;; let appliquer = List.map ;; (* affichage d'un noeud *)
Correction Code nécessaire à la compilation : let bs ="\\" let nl = "\n" let appliquer = List.map (* affichage d'un noeud *) let (noeud_vers_ch : int -> string) = function n -> "fib(" ^ (string_of_int
Les structures de données. Rajae El Ouazzani
Les structures de données Rajae El Ouazzani Les arbres 2 1- Définition de l arborescence Une arborescence est une collection de nœuds reliés entre eux par des arcs. La collection peut être vide, cad l
Objets 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
Programme Compte bancaire (code)
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; Programme Compte bancaire (code) namespace compte_bancaire /// Classe Program public
Les 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
Initiation à la programmation en Python
I-Conventions Initiation à la programmation en Python Nom : Prénom : Une commande Python sera écrite en caractère gras. Exemples : print 'Bonjour' max=input("nombre maximum autorisé :") Le résultat de
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
Java 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
Plan 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
Algorithmique, Structures de données et langage C
UNIVERSITE PAUL SABATIER TOULOUSE III Algorithmique, Structures de données et langage C L3 IUP AISEM/ICM Janvier 2005 J.M. ENJALBERT Chapitre 1 Rappels et compléments de C 1.1 Structures Une structure
Plan 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
Principes des langages de programmation INF 321. Eric Goubault
Principes des langages de programmation INF 321 Eric Goubault 24 mars 2014 2 Table des matières 1 Introduction 7 2 Programmation impérative 11 2.1 Variables et types........................... 11 2.2 Codage
Cours 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à
Arbres binaires de recherche
1 arbre des comparaisons 2 recherche dichotomique l'arbre est recalculé à chaque recherche 2 5 3 4 7 9 1 6 1 2 3 4 5 6 7 9 10 conserver la structure d'arbre au lieu de la reconstruire arbre binaire de
Cours No 3 : Identificateurs, Fonctions, Premières Structures de contrôle.
Université Montpellier-II UFR des Sciences - Département Informatique - Licence Informatique UE GLIN302 - Programmation Applicative et Récursive Cours No 3 : Identificateurs, Fonctions, Premières Structures
Programmation en Caml pour Débutants
Programmation en Caml pour Débutants Arthur Charguéraud 6 Ju 2005 Ceci est une version léaire imprimable du cours, mais il est fortement conseillé d utiliser la version teractive, sur laquelle la plupart
IN 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
TP3 : 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
STAGE IREM 0- Premiers pas en Python
Université de Bordeaux 16-18 Février 2014/2015 STAGE IREM 0- Premiers pas en Python IREM de Bordeaux Affectation et expressions Le langage python permet tout d abord de faire des calculs. On peut évaluer
Le prototype de la fonction main()
Le prototype de la fonction main() 1. Introduction...1 2. Paramètres et type de retour de la fonction main()...1 3. Exemple 1...2 4. La fonction exit() du C...2 5. Détecter le code de retour d un programme
Premiers 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.
Conventions 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
Brefs rappels sur la pile et le tas (Stack. / Heap) et les pointeurs
Brefs rappels sur la pile et le tas (Stack / Heap) et les pointeurs (exemples en C) v1.11 - Olivier Carles 1 Pile et Tas Mémoire allouée de manière statique Mémoire Allouée Dynamiquement variables locales
ACTIVITÉ DE PROGRAMMATION
ACTIVITÉ DE PROGRAMMATION The purpose of the Implementation Process is to realize a specified system element. ISO/IEC 12207 Sébastien Adam Une introduction 2 Introduction Ø Contenu Utilité de l ordinateur,
Pré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)
Vé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
Expression 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
TP 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
Logiciel Libre Cours 2 Fondements: Programmation
Logiciel Libre Cours 2 Fondements: Programmation Stefano Zacchiroli zack@pps.univ-paris-diderot.fr Laboratoire PPS, Université Paris Diderot 2013 2014 URL http://upsilon.cc/zack/teaching/1314/freesoftware/
Centre CPGE TSI - Safi 2010/2011. Algorithmique et programmation :
Algorithmique et programmation : STRUCTURES DE DONNÉES A. Structure et enregistrement 1) Définition et rôle des structures de données en programmation 1.1) Définition : En informatique, une structure de
Exceptions. 1 Entrées/sorties. Objectif. Manipuler les exceptions ;
CNAM NFP121 TP 10 19/11/2013 (Séance 5) Objectif Manipuler les exceptions ; 1 Entrées/sorties Exercice 1 : Lire un entier à partir du clavier Ajouter une méthode readint(string message) dans la classe
Logiciel 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/
TD3: 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
Algèbre binaire et Circuits logiques (2007-2008)
Université Mohammed V Faculté des Sciences Département de Mathématiques et Informatique Filière : SMI Algèbre binaire et Circuits logiques (27-28) Prof. Abdelhakim El Imrani Plan. Algèbre de Boole 2. Circuits
Algorithmique et Programmation Fonctionnelle
Algorithmique et Programmation Fonctionnelle RICM3 Cours 9 : Lambda-calcul Benjamin Wack Polytech 2014-2015 1 / 35 La dernière fois Typage Polymorphisme Inférence de type 2 / 35 Plan Contexte λ-termes
LES 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.
Les structures. Chapitre 3
Chapitre 3 Les structures Nous continuons notre étude des structures de données qui sont prédéfinies dans la plupart des langages informatiques. La structure de tableau permet de regrouper un certain nombre
Éléments d informatique Cours 3 La programmation structurée en langage C L instruction de contrôle if
Éléments d informatique Cours 3 La programmation structurée en langage C L instruction de contrôle if Pierre Boudes 28 septembre 2011 This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike
Vé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
INF111. Initiation à la programmation impérative en C http://ama.liglab.fr/ amini/cours/l1/inf111/ Massih-Reza Amini
Initiation à la programmation impérative en C http://ama.liglab.fr/ amini/cours/l1// Massih-Reza Amini Université Joseph Fourier Laboratoire d Informatique de Grenoble 2/52 Introduction Structures de contrôle
Algorithmique 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
Programmer 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
EPREUVE 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
Analyse de sécurité de logiciels système par typage statique
Contexte Modélisation Expérimentation Conclusion Analyse de sécurité de logiciels système par typage statique Application au noyau Linux Étienne Millon UPMC/LIP6 Airbus Group Innovations Sous la direction
Corrigé des TD 1 à 5
Corrigé des TD 1 à 5 1 Premier Contact 1.1 Somme des n premiers entiers 1 (* Somme des n premiers entiers *) 2 program somme_entiers; n, i, somme: integer; 8 (* saisie du nombre n *) write( Saisissez un
Programmation. fonctionnelle, impérative, logique et orientée objet
Programmation fonctionnelle, impérative, logique et orientée objet Introduction Les langages de programmation permettent de décrire des calculs de façon plus abstraite qu'un programme machine. Les programmes
Notions fondamentales du langage C# Version 1.0
Notions fondamentales du langage C# Version 1.0 Z 2 [Notions fondamentales du langage Csharp] [Date : 25/03/09] Sommaire 1 Tout ce qu il faut savoir pour bien commencer... 3 1.1 Qu est ce qu un langage
Cours de Programmation Impérative: Zones de mémoires et pointeurs
Cours de Programmation Impérative: Zones de mémoires et pointeurs Julien David A101 - david@lipn.univ-paris13.fr Julien David (A101 - david@lipn.univ-paris13.fr) 1 / 1 Z`o n`e s `d`e m`é m`o i r`e Julien
Compilation (INF 564)
Présentation du cours Le processeur MIPS Programmation du MIPS 1 Compilation (INF 564) Introduction & architecture MIPS François Pottier 10 décembre 2014 Présentation du cours Le processeur MIPS Programmation
Problème : Calcul d'échéanciers de prêt bancaire (15 pt)
Problème : Calcul d'échéanciers de prêt bancaire (15 pt) 1 Principe d'un prêt bancaire et dénitions Lorsque vous empruntez de l'argent dans une banque, cet argent (appelé capital) vous est loué. Chaque
Le Langage C Version 1.2 c 2002 Florence HENRY Observatoire de Paris Université de Versailles florence.henry@obspm.fr
Le Langage C Version 1.2 c 2002 Florence HENRY Observatoire de Paris Université de Versailles florence.henry@obspm.fr Table des matières 1 Les bases 3 2 Variables et constantes 5 3 Quelques fonctions indispensables
Programmation en Java IUT GEII (MC-II1) 1
Programmation en Java IUT GEII (MC-II1) 1 Christophe BLANC - Paul CHECCHIN IUT Montluçon Université Blaise Pascal Novembre 2009 Christophe BLANC - Paul CHECCHIN Programmation en Java IUT GEII (MC-II1)
Cours 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
RAPPELS SUR LES METHODES HERITEES DE LA CLASSE RACINE Object ET LEUR SPECIALISATION (i.e. REDEFINITION)
CLASSE RACINE Object ancêtre de toutes les classes RAPPELS SUR LES METHODES HERITEES DE LA CLASSE RACINE Object ET LEUR SPECIALISATION (i.e. REDEFINITION) définit donc des méthodes héritées par toutes
Corrigé des exercices sur les références
Corrigé des exercices sur les références Exercice 3.1.1 dessin Pour cet exercice, vous allez dessiner des structures de données au moyen de petits schémas analogues à ceux du cours, comportant la pile
Chapitre 10. Les interfaces Comparable et Comparator 1
Chapitre 10: Les interfaces Comparable et Comparator 1/5 Chapitre 10 Les interfaces Comparable et Comparator 1 1 Ce chapitre a été extrait du document "Objets, Algorithmes, Patterns" de [René Lalement],
C++ Programmer. en langage. 8 e édition. Avec une intro aux design patterns et une annexe sur la norme C++11. Claude Delannoy
Claude Delannoy Programmer en langage C++ 8 e édition Avec une intro aux design patterns et une annexe sur la norme C++11 Groupe Eyrolles, 1993-2011. Groupe Eyrolles, 2014, pour la nouvelle présentation,
TP, première séquence d exercices.
TP, première séquence d exercices. Benoît Valiron benoit.valiron@lipn.univ-paris13.fr 7 novembre 2010 Introduction Vous écrirez les réponses aux questions courtes sur une feuille à rendre à la fin de la
TP : Gestion d une image au format PGM
TP : Gestion d une image au format PGM Objectif : L objectif du sujet est de créer une classe de manipulation d images au format PGM (Portable GreyMap), et de programmer des opérations relativement simples
Les processus légers : threads. Système L3, 2014-2015 1/31
Les processus légers : threads Système L3, 2014-2015 1/31 Les threads Les threads sont des processus légers exécutés à l intérieur d un processus L exécution des threads est concurrente Il existe toujours
Qu est-ce qu une probabilité?
Chapitre 1 Qu est-ce qu une probabilité? 1 Modéliser une expérience dont on ne peut prédire le résultat 1.1 Ensemble fondamental d une expérience aléatoire Une expérience aléatoire est une expérience dont
Introduction à 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
Bases 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
V- Manipulations de nombres en binaire
1 V- Manipulations de nombres en binaire L ordinateur est constitué de milliards de transistors qui travaillent comme des interrupteurs électriques, soit ouverts soit fermés. Soit la ligne est activée,
Claude Delannoy. 3 e édition C++
Claude Delannoy 3 e édition Exercices Exercices C++ en en langage langage delc++ titre 4/07/07 15:19 Page 2 Exercices en langage C++ AUX EDITIONS EYROLLES Du même auteur C. Delannoy. Apprendre le C++.
Probabilités sur un univers fini
[http://mp.cpgedupuydelome.fr] édité le 7 août 204 Enoncés Probabilités sur un univers fini Evènements et langage ensembliste A quelle condition sur (a, b, c, d) ]0, [ 4 existe-t-il une probabilité P sur
Module Administration BD Chapitre 1 : Surcouche procédurale dans les SGBDS
Module Administration BD Chapitre 1 : Surcouche procédurale dans les SGBDS 1. Introduction Nous allons aborder la notion de surcouche procédurale au sein des SGBDS relationnels tels que Oracle (PLSQL)