Semaine 5 – Aspects impératifs, graphiques

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

jeudi 20 février 2014, 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.

(* 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 ();;

Télécharger

Dans la même rubrique

Semaine 5 – Aspects impératifs, graphiques

Recherche

Enseignement

Administration

Autres réalisations (logiciels, etc.)

Café

Divers