Semaine 5 – Aspects impératifs, graphiques

photo en cc-by-nc-sa par Hans Watson

, par Pierre

Encore un peu de récursion terminale (des corrections). Expression à évaluer (étant donné son arbre). Aspects impératifs : unit, for et while, enregistrements avec champs mutables, références, tableaux. Mode graphique.

  1. (* factorielle encore ! *)
  2. let rec factorielle = function
  3.   | 0 -> 1
  4.   | n -> (factorielle (n - 1))
  5.          * n
  6. ;;
  7.  
  8. (* et maintenant on peut l'ecrire en tail recursive *)
  9. let factorielle n =
  10.   let rec fact_tr n acc = match n with
  11.     | 0 -> acc
  12.     | n -> fact_tr (n - 1) (acc * n)
  13.   in
  14.   fact_tr n 1;;
  15.  
  16. (* evaluer une expression algebrique *)
  17. type expr = Nb of int
  18.           | Plus of expr * expr
  19.           | Mult of expr * expr
  20.           | Fact of expr
  21. ;;
  22. let x = Mult (Plus (Nb 3, Fact (Nb 4)), Nb 5);;
  23.  
  24. let rec eval = function
  25.   | Nb n -> n
  26.   | Plus (x, y) -> (eval x) + (eval y)
  27.   | Mult (x, y) -> (eval x) * (eval y)
  28.   | Fact x -> factorielle (eval x)
  29. ;;
  30.  
  31. eval x;;
  32.  
  33. (* tail recursion encore *)
  34.  
  35. (* renverser une liste *)
  36. let rec reverse = function
  37.   | [] -> []
  38.   | x::xs -> (reverse xs)@[x];;
  39.  
  40. reverse [2;3;4;5];;
  41.  
  42. let rec concat_reverse s acc = match s with
  43.   | [] -> acc
  44.   |  x::xs -> concat_reverse xs (x::acc)
  45. ;;
  46.  
  47. let reverse s = concat_reverse s [];;
  48.  
  49. reverse [2;3;4;5];;
  50. concat_reverse [3;2;1] [4;5;6];;
  51.  
  52. (* renverser une liste version tail recursive *)
  53.  
  54. (* fusionner deux listes triees *)
  55. let rec merge u v = match (u, v) with
  56.   | ([], []) -> []
  57.   | (s, []) -> s
  58.   | ([], t) -> t
  59.   | (x::s, y::t) when x < y -> x::(merge s v)
  60.   | (x::s, y::t) -> y::(merge u t)
  61. ;;
  62.  
  63. merge [1;1;2;5;6] [1;2;2;3;4;8];;
  64.  
  65. let merge u v =
  66.   let rec merge_tr u v acc = match (u, v) with
  67.     | ([], [])     -> reverse acc
  68.     | (x::s, [])   -> merge_tr s [] (x::acc)
  69.     | ([], y::t)   -> merge_tr [] t (y::acc)
  70.     | (x::s, y::t) when x < y
  71.       -> merge_tr s v (x::acc)
  72.     | (x::s, y::t) -> merge_tr u t (y::acc)
  73.   in
  74.   merge_tr u v []
  75. ;;
  76.  
  77. merge [1;1;2;5;6] [1;2;2;3;4;8];;
  78.  
  79. (* aspects impératifs *)
  81. ();;
  82.  
  83. (* for et  while *)
  84.  
  86. for i = 0 downto -5 do
  87.   print_int i;
  89. done;
  90. ;;
  91.  
  92. (* enregistrements *)
  93. (3, "Foo", "Bar", 14.5);;
  94.  
  95. type etudiant = {
  96.   numero: int;
  97.   prenom: string;
  98.   nom: string;
  99.   note: float;
  100. };;
  101.  
  102. let foobar =
  103.   {numero = 3;
  104.    prenom = "Foo"; nom = "Bar";
  105.    note = 14.5
  106. };;
  107.  
  108. let  etudiant_to_note e =
  109.   e.note
  110. ;;
  111.   etudiant_to_note foobar;;
  112. foobar.note;;
  113.  
  114. type accord  = {
  115.          mode: string;
  116.          note: string;
  117.        };;
  118.  
  119. let doM = {note= "do"; mode = "Majeur" };;
  120.   etudiant_to_note;;
  121.   etudiant_to_note doM;;
  122.  
  123. let tonote e =
  124.     e.note;;
  125.  
  126.  
  127. type point = {x: float; y: float};;
  128. let a = {x = 100.; y = 200.};;
  129. let add a b =
  130.   {x = a.x +. b.x;
  131.    y = a.y +. b.y;
  132.   };;
  133.  
  134. (* sucre syntaxique : créer un opérateur infixe *)
  135. let ( +: ) = add;;
  136. a +: a;;
  137.  
  138. let ( *: ) = fun lambda a -> {
  139.   x = lambda *. a.x;
  140.   y = lambda *. a.y;
  141. };;
  142.  
  143. (0.5 *: a) +: a;;
  144.  
  145. (* mutable *)
  146. type machin = {
  147.   mutable truc: int;
  148.   chose: int;
  149. };;
  150. let a = {truc = 45; chose = 67};;
  151. a.truc;;
  152. a.truc <- 34;;
  153. a.truc;;
  154.  
  155. (* a.chose <- 36;;  refusé *)
  156.  
  157.  
  158. (* plutot que de faire *)
  159. type entiermutable = {mutable valeur: int};;
  160. let a = {valeur = 45};;
  161. a.valeur <- 34;;
  162.  
  163. (* On a une notation pour la meme chose, plus pratique, sans declarer *)
  164. (* de type *)
  165.  
  166. (* cela s'appelle les références, nos variables impératives en ocaml *)
  167. let a = ref 45;;
  168. a := 35;;
  169. !a;;
  170. !a + 3;;
  171.  
  172. (* factorielle iterative *)
  173. let fact n =
  174.   let produit = ref 1 in
  175.   for i = 1 to n do
  176.     produit := !produit * i;
  177.   done;
  178.   !produit
  179. ;;
  180.  
  181. fact 4;;
  182.  
  183. (* tableaux *)
  184. (1,2,3);; (* tuple *)
  185. [1;2;3];; (* liste *)
  186. let tab = [|1;2;3|];; (* tableau ! *)
  187. tab.(0) <- tab.(2) + 1;;
  188. tab;;
  189.  
  190. Array.to_list tab;;
  191. Array.of_list [1;3;4;5];;
  192. Array.map
  193.   (function x -> x + 45)
  194.   tab;;
  195.  
  196. (* dessiner *)
  197. #load "graphics.cma"
  198. (* open Graphics;; ou bien *)
  199. module G = Graphics;;
  200.  
  201. (* ouvrir l'affichage graphique
  202. /!\ noter l'espace en début de chaîne *)
  203. G.open_graph " 1000x800";;
  204.  
  205. (* choisir une couleur *)
  206. G.set_color 0xFFCC00;;
  207.  
  208. (* dessiner un polygone plein *)
  209. G.fill_poly (Array.map
  210.                (function (x,y) -> (x + 500, y + 400))
  211.                [|(4,5); (100, 56); (45,60);|]);;
  212.  
  213. (* effacer l'écran *)
  214. G.clear_graph ();;
  215.  
  216. (* ne plus synchroniser automatiquement buffer et ecran *)
  217. G.auto_synchronize false;;
  218.  
  219. (* ne plus ecrire dans le buffer *)
  220. G.display_mode true;;
  221. G.remember_mode false;;
  222.  
  223. (* dessiner la forme pleine en jaune *)
  224. G.set_color 0xFFCC00;;
  225. let forme = (Array.map
  226.                (function (x,y) -> (x + 500, y + 400))
  227.                [|(4,5); (100, 56); (45,60);|]);;
  228. G.fill_poly forme;;
  229.  
  230. (* dessiner dans le buffer et sur l'écran *)
  231. G.display_mode true;;
  232. G.remember_mode true;;
  233.  
  234. (* dessiner le contour de de la forme *)
  235. G.set_color 0xFF00FF;;
  236. G.set_line_width 3;;
  237. G.draw_poly forme;;
  238.  
  239. (* copier le buffer sur l'ecran *)
  240. G.synchronize ();; (* affiche la forme creuse *)
  241.  
  242. (* fermer l'affichage graphique *)
  243. G.close_graph ();;

Télécharger

Recherche

Enseignement

Administration

Curriculum Vitæ [pdf]
Comment me contacter

Autres réalisations (logiciels, etc.)

Thymio, Python et Asebamedulla
des QCM en ligne grâce à org-mode (et jQuery, et MathJax), org-mode [org, html, css]

Café

Enseigner la programmation
Revenu et logement, Je livre ici quelques éléments de comparaison concernant mon niveau de vie, pour couper court à quelques idées reçues, et un condensé de nombreuses (...)
Revenu et travail d’un enseignant-chercheur, Cet article complète l'article Revenu et logement, en détaillant un peu le budget de mon ménage, mon parcours d'enseignant-chercheur en terme de (...)
Paris 13 Villetaneuse, pas encore la vélorution !
Cybersyn (el systemo synco), Au café, mardi 5 avril 2011, j'ai bien vu que, mis à part Antoine Allombert, personne ne connaissait l'histoire de l'extraordinaire projet chilien (...) [jpg, jpg, png]

Divers

Affiche CiE 2016
Augmenter l’espace de stockage d’un hote GNU/Linux (VirtualBox etc.)
AperoTIC sur les réseaux sociaux
ADULLACT, Pour être un peu moins seul à défendre l'usage et le développement de logiciels libres dans mon travail (et autour), j'ai adhéré à l'ADULLACT en tant (...)
Hacker l’éducation (Open bidouille camp 2 // Fac lab de Gennevilliers)
Expo : et l’Homme… créa le robot
MathJax
Onglets dans un rapport $\LaTeX$ [gz, png, pdf, gz]
Logo LIPN et accessoires [svg, svg, png, tex, pdf, tif, zip, png, eps, svg]
Ventilo pour ibook (retrouvé) [jpg]