Semaine 5 – Aspects impératifs, graphiques

(* factorielle encore ! *)
let rec factorielle = function
  | 0 -> 1
  | n -> (factorielle (n - 1))
         * n
;;
 
(* et maintenant on peut l'ecrire en tail recursive *)
let factorielle n =
  let rec fact_tr n acc = match n with
    | 0 -> acc
    | n -> fact_tr (n - 1) (acc * n)
  in
  fact_tr n 1;;
 
(* evaluer une expression algebrique *)
type expr = Nb of int
          | Plus of expr * expr
          | Mult of expr * expr
          | Fact of expr
;;
let x = Mult (Plus (Nb 3, Fact (Nb 4)), Nb 5);;
 
let rec eval = function
  | Nb n -> n
  | Plus (x, y) -> (eval x) + (eval y)
  | Mult (x, y) -> (eval x) * (eval y)
  | Fact x -> factorielle (eval x)
;;
 
eval x;;
 
(* tail recursion encore *)
 
(* renverser une liste *)
let rec reverse = function
  | [] -> []
  | x::xs -> (reverse xs)@[x];;
 
reverse [2;3;4;5];;
 
let rec concat_reverse s acc = match s with
  | [] -> acc
  |  x::xs -> concat_reverse xs (x::acc)
;;
 
let reverse s = concat_reverse s [];;
 
reverse [2;3;4;5];;
concat_reverse [3;2;1] [4;5;6];;
 
(* renverser une liste version tail recursive *)
 
(* fusionner deux listes triees *)
let rec merge u v = match (u, v) with
  | ([], []) -> []
  | (s, []) -> s
  | ([], t) -> t
  | (x::s, y::t) when x < y -> x::(merge s v)
  | (x::s, y::t) -> y::(merge u t)
;;
 
merge [1;1;2;5;6] [1;2;2;3;4;8];;
 
let merge u v =
  let rec merge_tr u v acc = match (u, v) with
    | ([], [])     -> reverse acc
    | (x::s, [])   -> merge_tr s [] (x::acc)
    | ([], y::t)   -> merge_tr [] t (y::acc)
    | (x::s, y::t) when x < y
      -> merge_tr s v (x::acc)
    | (x::s, y::t) -> merge_tr u t (y::acc)
  in
  merge_tr u v []
;;
 
merge [1;1;2;5;6] [1;2;2;3;4;8];;
 
(* aspects impératifs *)
print_int 50;;
();;
 
(* for et  while *)
 
print_newline ();
for i = 0 downto -5 do
  print_int i;
  print_newline ();
done;
;;
 
(* enregistrements *)
(3, "Foo", "Bar", 14.5);;
 
type etudiant = {
  numero: int;
  prenom: string;
  nom: string;
  note: float;
};;
 
let foobar =
  {numero = 3;
   prenom = "Foo"; nom = "Bar";
   note = 14.5
};;
 
let  etudiant_to_note e =
  e.note
;;
  etudiant_to_note foobar;;
foobar.note;;
 
type accord  = {
         mode: string;
         note: string;
       };;
 
let doM = {note= "do"; mode = "Majeur" };;
  etudiant_to_note;;
  etudiant_to_note doM;;
 
let tonote e =
    e.note;;
 
 
type point = {x: float; y: float};;
let a = {x = 100.; y = 200.};;
let add a b =
  {x = a.x +. b.x;
   y = a.y +. b.y;
  };;
 
(* sucre syntaxique : créer un opérateur infixe *)
let ( +: ) = add;;
a +: a;;
 
let ( *: ) = fun lambda a -> {
  x = lambda *. a.x;
  y = lambda *. a.y;
};;
 
(0.5 *: a) +: a;;
 
(* mutable *)
type machin = {
  mutable truc: int;
  chose: int;
};;
let a = {truc = 45; chose = 67};;
a.truc;;
a.truc <- 34;;
a.truc;;
 
(* a.chose <- 36;;  refusé *)
 
 
(* plutot que de faire *)
type entiermutable = {mutable valeur: int};;
let a = {valeur = 45};;
a.valeur <- 34;;
 
(* On a une notation pour la meme chose, plus pratique, sans declarer *)
(* de type *)
 
(* cela s'appelle les références, nos variables impératives en ocaml *)
let a = ref 45;;
a := 35;;
!a;;
!a + 3;;
 
(* factorielle iterative *)
let fact n =
  let produit = ref 1 in
  for i = 1 to n do
    produit := !produit * i;
  done;
  !produit
;;
 
fact 4;;
 
(* tableaux *)
(1,2,3);; (* tuple *)
[1;2;3];; (* liste *)
let tab = [|1;2;3|];; (* tableau ! *)
tab.(0) <- tab.(2) + 1;;
tab;;
 
Array.to_list tab;;
Array.of_list [1;3;4;5];;
Array.map
  (function x -> x + 45)
  tab;;
 
(* dessiner *)
#load "graphics.cma"
(* open Graphics;; ou bien *)
module G = Graphics;;
 
(* ouvrir l'affichage graphique
/!\ noter l'espace en début de chaîne *)
G.open_graph " 1000x800";;
 
(* choisir une couleur *)
G.set_color 0xFFCC00;;
 
(* dessiner un polygone plein *)
G.fill_poly (Array.map
               (function (x,y) -> (x + 500, y + 400))
               [|(4,5); (100, 56); (45,60);|]);;
 
(* effacer l'écran *)
G.clear_graph ();;
 
(* ne plus synchroniser automatiquement buffer et ecran *)
G.auto_synchronize false;;
 
(* ne plus ecrire dans le buffer *)
G.display_mode true;;
G.remember_mode false;;
 
(* dessiner la forme pleine en jaune *)
G.set_color 0xFFCC00;;
let forme = (Array.map
               (function (x,y) -> (x + 500, y + 400))
               [|(4,5); (100, 56); (45,60);|]);;
G.fill_poly forme;;
 
(* dessiner dans le buffer et sur l'écran *)
G.display_mode true;;
G.remember_mode true;;
 
(* dessiner le contour de de la forme *)
G.set_color 0xFF00FF;;
G.set_line_width 3;;
G.draw_poly forme;;
 
(* copier le buffer sur l'ecran *)
G.synchronize ();; (* affiche la forme creuse *)
 
(* fermer l'affichage graphique *)
G.close_graph ();;