TP13 : Compilation et exécution en ligne de commande d’un programme ocaml
Exercice 1 : Mise en jambe.
ocaml
On peut afficher un entier en ocaml avec la fonction print_int :
int -> unit (nous reviendrons en cours sur ce que signifie unit,
pour l’instant considérez que la fonction ne renvoie rien) et une
chaîne de caractères avec la fonction print_string : string -> unit
pour afficher une chaîne.
Écrire un programme ocaml qui affiche bonjour suivi d’un retour à la
ligne, le compiler en ligne de commande avec ocamlopt et
l’exécuter. (Rappel: l’exécution d’un programme ocaml est
l’évaluation de la dernière expression du code.)
L’exécuter en redirigeant sa sortie standard vers le fichier toto.
Exercice 2 : Tracé de points en ascii art
Le but de cet exercice est de partir d’une description de pixels du
plan (donc d’éléments de
) donnés sous
la forme d’une abscisse de départ et d’une suite d’ordonnées,
l’abscisse de départ étant associée à la première ordonnée et
l’abscisse augmentant de 1 à chaque nouvelle ordonnée, et de dessiner
une représentation de ces pixels à l’écran sous la forme d’espaces ` ` pour
les pixels blancs et de
x pour les pixels noirs.
exemple : On a au départ :
- abscisse : 2
- ordonnées : 1, 5, 3, 4, 3 Les points à représentés sont alors : (2, 1), (3, 5), (4, 3), (5, 4), (6, 3).
Pour cela, on procède en deux phases :
- fabriquer la suite des points en les triant selon les ordonnées décroissantes, et si plusieurs points ont la mêm ordonnée, selon les abscisses croissantes; dans l’exemple, on obtiendrait : (3, 5), (5, 4), (4, 3), (6, 3) , (2, 1);
- dessiner les points correspondants; dans l’exemple on obtiendrait :
x
x
x x
x
Le fichier d’interface pour la partie ocaml : point.mli
Écrire les fonctions maximum, liste_points et affiche qui sont
documentées dans le fichier d’interface point.mli, en les testant au fur
et à mesure (conserver les fonctions de test dans votre code, en
commentant si besoin les lignes d’appel correspondantes).
Exercice 3 : Algorithme de tracé de segment de Bresenham
L’algorithme de tracé de segment de Bresenham permet de tracer un segment sur un écran, comme illustré par
Un écran peut être assimilé à une partie finie du quart de plan discret
.
Considérons deux points distincts
et
de
cet écran et supposons pour simplifier que
et
et
que la pente de la droite
est strictement
inférieure à 1. Le
segment
est donc situé entre les abscisses
et
. On
cherche une représentation de ce segment par une suite de points
où
et l’abscisse de
est
pour chaque
.
L’ordonnée du point d’abscisse du segment
est
.
Le problème, c’est que cette valeur est rarement entière. Il faut donc
faire un choix entre le partie entière inférieure et la partie entière
supérieure de cette valeur pour chaque : on prend celui des deux
qui est le plus proche de
. Notons
le
choix qu’on fait entre les deux pour l’ordonnée du point d’abscisse
:
Par construction : et
.
L’hypothèse selon laquelle la pente de la droite est
strictement inférieure à 1 nous assure que :
L’algorithme de Bresenham permet d’éviter les calculs des valeurs
exactes des .
Notons
la pente de la droite et
l’erreur d’arrondi accumulée. Au départ,
puisque les
coordonnées de
sont entières. À chaque étape, l’erreur augmente de
:
- si
, alors
et on incrémente
de
- sinon,
et on affecte à
.
On conserve les types définis à l’exercice précédent (et les fonctions déjà écrites ne devraient pas être inutiles !).
Écrire une fonction bresenham : point -> point -> int list telle
que bressenham a b renvoie la liste des ordonnées des points intermédiaires
(les pré-conditions sont supposées, mais ne sont pas à tester).
Écrire une fonction affiche_segment : point -> point -> unit pour
l’affichage du segment.
Écrire un programme pour tester le tout.