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 *)
  80. ();;
  81.  
  82. (* for et  while *)
  83.  
  84. for i = 0 downto -5 do
  85.   print_int i;
  86. done;
  87. ;;
  88.  
  89. (* enregistrements *)
  90. (3, "Foo", "Bar", 14.5);;
  91.  
  92. type etudiant = {
  93.   numero: int;
  94.   prenom: string;
  95.   nom: string;
  96.   note: float;
  97. };;
  98.  
  99. let foobar =
  100.   {numero = 3;
  101.    prenom = "Foo"; nom = "Bar";
  102.    note = 14.5
  103. };;
  104.  
  105. let  etudiant_to_note e =
  106.   e.note
  107. ;;
  108.   etudiant_to_note foobar;;
  109. foobar.note;;
  110.  
  111. type accord  = {
  112.          mode: string;
  113.          note: string;
  114.        };;
  115.  
  116. let doM = {note= "do"; mode = "Majeur" };;
  117.   etudiant_to_note;;
  118.   etudiant_to_note doM;;
  119.  
  120. let tonote e =
  121.     e.note;;
  122.  
  123.  
  124. type point = {x: float; y: float};;
  125. let a = {x = 100.; y = 200.};;
  126. let add a b =
  127.   {x = a.x +. b.x;
  128.    y = a.y +. b.y;
  129.   };;
  130.  
  131. (* sucre syntaxique : créer un opérateur infixe *)
  132. let ( +: ) = add;;
  133. a +: a;;
  134.  
  135. let ( *: ) = fun lambda a -> {
  136.   x = lambda *. a.x;
  137.   y = lambda *. a.y;
  138. };;
  139.  
  140. (0.5 *: a) +: a;;
  141.  
  142. (* mutable *)
  143. type machin = {
  144.   mutable truc: int;
  145.   chose: int;
  146. };;
  147. let a = {truc = 45; chose = 67};;
  148. a.truc;;
  149. a.truc <- 34;;
  150. a.truc;;
  151.  
  152. (* a.chose <- 36;;  refusé *)
  153.  
  154.  
  155. (* plutot que de faire *)
  156. type entiermutable = {mutable valeur: int};;
  157. let a = {valeur = 45};;
  158. a.valeur <- 34;;
  159.  
  160. (* On a une notation pour la meme chose, plus pratique, sans declarer *)
  161. (* de type *)
  162.  
  163. (* cela s'appelle les références, nos variables impératives en ocaml *)
  164. let a = ref 45;;
  165. a := 35;;
  166. !a;;
  167. !a + 3;;
  168.  
  169. (* factorielle iterative *)
  170. let fact n =
  171.   let produit = ref 1 in
  172.   for i = 1 to n do
  173.     produit := !produit * i;
  174.   done;
  175.   !produit
  176. ;;
  177.  
  178. fact 4;;
  179.  
  180. (* tableaux *)
  181. (1,2,3);; (* tuple *)
  182. [1;2;3];; (* liste *)
  183. let tab = [|1;2;3|];; (* tableau ! *)
  184. tab.(0) <- tab.(2) + 1;;
  185. tab;;
  186.  
  187. Array.to_list tab;;
  188. Array.of_list [1;3;4;5];;
  189. Array.map
  190.   (function x -> x + 45)
  191.   tab;;
  192.  
  193. (* dessiner *)
  194. #load "graphics.cma"
  195. (* open Graphics;; ou bien *)
  196. module G = Graphics;;
  197.  
  198. (* ouvrir l'affichage graphique
  199. /!\ noter l'espace en début de chaîne *)
  200. G.open_graph " 1000x800";;
  201.  
  202. (* choisir une couleur *)
  203. G.set_color 0xFFCC00;;
  204.  
  205. (* dessiner un polygone plein *)
  206. G.fill_poly (Array.map
  207.                (function (x,y) -> (x + 500, y + 400))
  208.                [|(4,5); (100, 56); (45,60);|]);;
  209.  
  210. (* effacer l'écran *)
  211. G.clear_graph ();;
  212.  
  213. (* ne plus synchroniser automatiquement buffer et ecran *)
  214. G.auto_synchronize false;;
  215.  
  216. (* ne plus ecrire dans le buffer *)
  217. G.display_mode true;;
  218. G.remember_mode false;;
  219.  
  220. (* dessiner la forme pleine en jaune *)
  221. G.set_color 0xFFCC00;;
  222. let forme = (Array.map
  223.                (function (x,y) -> (x + 500, y + 400))
  224.                [|(4,5); (100, 56); (45,60);|]);;
  225. G.fill_poly forme;;
  226.  
  227. (* dessiner dans le buffer et sur l'écran *)
  228. G.display_mode true;;
  229. G.remember_mode true;;
  230.  
  231. (* dessiner le contour de de la forme *)
  232. G.set_color 0xFF00FF;;
  233. G.set_line_width 3;;
  234. G.draw_poly forme;;
  235.  
  236. (* copier le buffer sur l'ecran *)
  237. G.synchronize ();; (* affiche la forme creuse *)
  238.  
  239. (* fermer l'affichage graphique *)
  240. G.close_graph ();;

Télécharger

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 (...)
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]