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