Projet Caml : Codage de Huffman

Projet Caml :
Codage de Huffman
Didier Siphaxay
1A INFO N7 : Groupe F
11 d´ecembre 2007
R´esum´e
Ce projet est bas´e sur l’algorithme de compression / d´ecompression cr´ee par M. Huffman en 1952
.La compression de donn´ees fait partie du quotidien de millions d’utilisateurs d’ordinateurs `a travers
le monde. Avec la multiplication des sources d’informations il est pr´ef´erable de mieux g´erer l’espace
m´emoire qui est souvent assez limit´e sur nos machines mˆeme si de nos jours les capacit´es sont de plus
en plus grandes pour une taille de plus en plus petite.
1

Siphaxay Didier
Programmation fonctionnelle CAML Projet P1
Table des mati`eres
1 Pr´esentation g´en´erale 3
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Distribution fournie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Les sp´ecifications exig´ees du sujet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.4 Choix de sp´ecifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Conception 6
2.1 Structure globale de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2 Burrows Wheeler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 Move to Front . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.4 Huffman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3 Codage 10
3.1 Burrows Wheeler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.2 Move to Front . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3 Huffman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4 Tests 14
4.1 M´ethodes de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5 Conclusion 16
5.1 Travail effectu´e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
5.2 Le langage Caml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
5.3 Avis personel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
6 Annexes 17
6.1 Listing des fichiers de test (globaux) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.2 Statistiques sur les tests usines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2

Siphaxay Didier
Programmation fonctionnelle CAML Projet P1
1 Pr´esentation g´en´erale
1.1 Introduction
L’objectif de ce projet est la r´ealisation d’un algorithme de compression / d´ecompression bas´e sur
les arbres de Huffman. Pour am´eliorer l’efficacit´e de cette technique, deux autres m´ethodes lui seront
adjointes : la m´ethode de Burrows-wheeler ainsi que celle du ”Move-to-Front”.
Pour compresser des donn´ees, on utilise une compression par arbre (m´ethode d’Huffman). Celle ci
peut se d´ecomposer ainsi : on va d’abord s´eparer la donn´ee source en unit´es de mˆeme taille (e.g. des
caract`eres) et associer chacune de ces unit´es `a sa multiplicit´e dans dans la donn´ee source. Cette m´ethode
est ainsi semi-adaptative, en effet on analyse une premi`ere fois le document afin d’extraire des statistiques
sur les unit´es que l’on range dans l’arbre d’huffman pour pouvoir mieux optimiser la compression. Il existe
bien d’autres m´ethodes qui sont bas´es soit sur la fr´equence d’apparatition de l’unit´e dans une langue soit
d’autres param`etres.
Pour retrouver l’ordonnancement de ces unit´es, on va se servir d’une suite de bits qui nous permettra
de naviguer dans l’arbre ainsi compos´e. Le nombre de bit attribu´e `a une unit´e d´ependra de sa multiplicit´e
dans la donn´ee source, ainsi les unit´es les plus fr´equentes seront cod´es sur un code binaire tr`es court alors
que les donn´ees relativement peu pr´esentes le seront par des codes plus long.
Pour am´eliorer l’efficacit´e de cette m´ethode. on va adjoindre une m´ethode de codage diff´erentiel
qui va ´evaluer les distances entre les unit´es et leurs pr´ec´edentes dans la donn´ees sources. Cette m´ethode
ne compresse pas les donn´ees mais permet d’obtenir une compression plus ´el´ev´es grˆace au codage de
Huffman dans le cas o`u les occurences d’une mˆeme unit´e sont proches. En effet dans ce cas les distantes
sont relativement petites et on obtient donc une sensible augmentation de donn´ee redondantes (gage de
bonne compression pour la compression par arbre). C’est l’objet de la m´ethode ”Move-to-front”.
Enfin pour favoriser la m´ethode pr´ecedente, la m´ethode de ”Burrows-wheeler” entre en jeu. Cette
m´ethode n’est rien d’autre qu’une m´ethode permettant de rapprocher les unit´es identiques entre elles afin
de r´eduire leurs distances relatives dans la donn´ee source. Elle n’engendre elle non plus aucun gain de
compression mais elle est facilement reversible. Cette m´ethode est cependant assez lourde et ne peut ˆetre
appliqu´e `a des donn´ees trop grandes.
1.2 Distribution fournie
Voici le listing des fournitures de l’archive qui a ´et´e mise `a notre disposition pour ce projet.
– main.cmo
– defaut.mli
– defaut.cmi
– defaut.cmo
– huffman.mli
– movetofront.mli
– burrows wheeler.mli
– Makefile
– . . .
Les diff´erents fichiers ”mli” sont des fichiers de sp´ecification que l’on respecte au travers des types `a
adopter pour le codage. Ces derni`eres assurent l’interface entre le programme principal et les diff´erents
modules mis en place.
L’item ”main.cmo” est le fichier objet issue de la compilation du projet. Cet objet est donc la pour
assurer la derni`ere ´etape de la cr´eation de l’´ex´ecutable ”huffman” par le proc´ed´e d’´edition des liens grˆace
`a la commande ”make”. Les phases d’entr´ees-sorties ainsi que l’interaction avec l’utilisateur qui permet
d’appeler les diff´erents modules en mode encodage ou d´ecodage sont implant´ees dans ce fichier.
Les items ”defaut.cmo”, ”defaut.cmi”, ”defaut.mli” sont des fichiers qui permettent de remplacer
les fonctions que l’on doit coder dans le cas d’un malfonctionnement de ces derniers. Ces fichiers ne
permettent aucune compression des donn´ees et servent donc seulement de support pour la compilation.
3

Siphaxay Didier
Programmation fonctionnelle CAML Projet P1
Enfin le fichier ”Makefile” est un fichier contenant des commandes shell qui permettent de compiler et
faire l’´edition des liens de l’ensemble du programme. On peut ais´ement les programmer pour n’importe
quel type de langage. Leur utilisation passe par la commande ”make”.
Les bases ´etant pos´ees on doit se questionner sur les contraintes du projet : on en a d´ej`a un exemple
avec les diff´erents fichiers mis `a notre disposition.
1.3 Les sp´ecifications exig´ees du sujet
Le projet doit ˆetre ´ecrit en Caml, langage de programmation impos´e, et ceci dans un style program-
mation fonctionnelle i.e. sans tableaux, ni r´eferences, ni proc´edures.
Pour ce projet, il nous a ´et´e fournie une distribution qui restreint d´ej`a notre travail. En effet les
fichiers ”mli” cit´es pr´ec´edemment sont l`a pour poser un contrat entre le programmeur et le sp´ecificateur
en ´enon¸cant les profils des fonctions attendues.
Voici toutes les fonctionnalit´es d´evelopp´ees dans le cadre de ce projet que l’on peut retrouver dans les
fichiers ’mli’.
– Burrows wheeler : encode
Encode en utilisant la transform´ee de Burrows-Wheeler.
Renvoie l’indice de position ainsi que la s´equence des derniers caract`eres
– Burrows wheeler : decode
D´ecode la s´equence `a partir de l’indice de position et la s´equence des derniers caract`eres.
– Move to front : encode
Encode une liste d’unit´es grˆace `a une fonction de codage arbitraire par d´efaut. Pour les caract`eres,
cela peut ˆetre le code ASCII par exemple
– Move to front : decode
D´ecode la liste d’unit´es grˆace `a une fonction de d´ecodage par d´efaut. Cette fonction doit ˆetre la
r´eciproque de celle utilis´ee par la fonction ’encode’
– Huffman : type ’a huffman (`a definir)
Type de l’arbre binaire utilis´e pour coder le document
– Huffman : build-tree
Prend une liste d’´el´ements et construit l’arbre de codage
– Huffman : encode
Prend une liste d’´el´ements et renvoie le couple (arbre de codage de huffman, codage binaire de la
liste)
– Huffman : decode
Prend un arbre de codage de huffman et une liste de bool´eens et reconstruit la liste d’´el´ements
d´ecod´ee
Un jeu de test sera ´elabor´e pour un ”test site” permettant de v´erifier la fonctionnalit´e du programme
pr´esent´e. Ce jeu de test devra ˆetre le plus fin possible rassemblant l’int´egralit´e des cas possibles ou du
moins dans les limites pos´ees par le programme principal cod´e dans le fichier ”main.cmo”.
4

Siphaxay Didier
Programmation fonctionnelle CAML Projet P1
1.4 Choix de sp´ecifications
Contraintes personnelles : mˆeme si le client ne l’a expressement pas ´exiger, pour un souci de rapidit´e, je
pr´efererai concevoir les diff´erentes fonctionnalit´es dans un vision d’optimisation temporelle puisque c’est
une priorit´e qui sera impos´e dans le travail d’ing´enieur. Le deuxi`eme effet ´etant de ne pas faire patienter
l’utilisateur du programme trop longtemps avant d’avoir un r´esultat.
Le choix majeur dans ce projet fut l’´elaboration d’un type ’a huffman de fa¸con `a optimiser la
taille de la donn´ee compress´e. Pour cela on a du passer d’abord par un type qui permettait d’´equilibrer
l’arbre de codage pour permettre d’obtenir des codes binaires d’une longueur de ’log n’ pour un ´el´ement
d’une liste de longueur n.
Listing 1: Type ’a arbre : type interm´ediaire
type ’a arbre =
|Feuille of int ∗’a
|Noeud of (’a arbre∗int∗’a arbre );;
Listing 2: Type ’a huffman
type ’a huffman =
|Vide
|Leaf of ’ a
|Node of ’a huffman∗’a huffman;;
La liste bool´eene associ´e `a cet arbre est un peu `a part mais fait partie enti`ere de la donn´ee compress´ee.
Les fonctionnalit´ees auxquelles aura acc`es l’utilisateur sont au nombre de, en tout et pour tout,
2 ; celle pour compresser les donn´ees et celle pour d´ecompresser des fichiers. Ceci `a travers les commandes
suivantes :
– huffman -e <<fichier>> : produit le fichier cod´e <<fichier>>.encoded `a partir du fichier source
<<fichier>>
– huffman -d <<fichier>> : produit le fichier d´ecod´e <<fichier>>.decoded `a partir du fichier cod´e
<<fichier>>.encoded
5