Bla

1 files changed, 55 insertions, 105 deletions

diff --git a/doc/manuel.tex b/doc/manuel.tex
index fcdc3af..d1522f0 100644
--- a/doc/manuel.tex
+++ b/doc/manuel.tex
@@ -1,124 +1,74 @@
 \chapter{Manuel d'utilisation}
 \paragraph{}
-Ce projet génère deux binaire. Le premier appelé testTas n'est qu'une petite application nous permettant d'utiliser l'API
-C++ générée par notre classe de file de priorités. Voici un exemple d'exécution:
+Lorsque le programme principal se lance, nous obtenons un invite simple:
 \begin{verbatim}
-Priority list type: 0 - Binary Heap
-Choice: Please select an action
-a - Add a key into the priority list
-c - Change priority list type
-d - Delete a Key from the priority list
-e - Extract Min onto the priority list
-l - Lower Key onto a key of the priority list
-p - Print the current priority list on the screen
-r - Remove the whole priority list
-t - Test the priority list algorithms
-q - Quit
-\end{verbatim}
+$ ./Polynom 
+Polynomia v1.0
 
-A partir de cet instant, le programme nous propose un menu nous permettant d'effectuer plusieurs actions sur le tas. La
-fonction 'a' permet d'ajouter une clef dans le tas en cours. Comme il est impossible d'effectuer une recherche sur un tas
-pour y retrouver le pointeur d'un élément, le programme nous propose de sauvegarder le pointeur résultat dans un tableau:
 
-\begin{verbatim}
-Choice: Please select a slot to save the cell
-0 - Empty slot
-1 - Empty slot
-2 - Empty slot
-3 - Empty slot
-4 - Empty slot
-5 - Empty slot
-6 - Empty slot
-7 - Empty slot
-8 - Empty slot
-9 - Empty slot
-n - Don't store
-c - Cancel
-\end{verbatim}
+Performing initialisation...
 
-Ce tableau apparaitra régulièrement dans toutes les fonctions du menu afin de choisir une cellule sur laquelle agir. Toutes
-les fonctions du menu parlent d'elles mêmes. La fonction 't' va lancer une batterie de tests sur les algorithmes de la
-file de priorité sélectionnée.
 
-\paragraph{}
-Le deuxième binaire généré est 'Huffman'. Il sert à utiliser l'algorithme d'huffman implémenté. Voici sa ligne d'aide:
-\begin{verbatim}
-$ ./Huffman -h
-Huffman [{-f|-i} file] {type}
-Huffman -h
-This will encode the input file with the Huffman code
-using the priority list defined by type.
-Type is a number taken from this list:
-  0 : Binary Heap (default)
-  1 : Binomial Heap
-  2 : Fibonacci Heap
-  3 : Sorted chained list
--f file means that you specify a dictionnary file which is
-        structured as described into the README file.
--i file means that you specify a file to encode. It will
-        built a quiet dumb dictionnary.
-By default, a dictionnary will be built from stdin.
--h prints this help and exit.
+Starting interface...
+
+> 
 \end{verbatim}
 
-La structure d'un dictionnaire est la suivante:
+La flexibilité de l'interface est extrème, et nous permet, à la manière MAPLE, de taper sous une
+forme naturelle nos polynomes. Voici un exemple d'utilisation "simple":
+
 \begin{verbatim}
-Mot1 : Fréquence1
-Mot2 : Fréquence2
-...
+> A = x^4 + 2*x^3 - x + 6;
+
+ .   x^4 + 2x^3 - x + 6 
+
+> B = x^3 - 6*x^2 + x + 4;
+
+ .   x^3 - 6x^2 + x + 4 
+
+> A + B;
+
+ .   x^4 + 3x^3 - 6x^2 + 10 
+
+> A - B;
+
+ .   x^4 + x^3 + 6x^2 - 2x + 2 
+
+> A / B;
+
+ .   x + 8 
+
+> A % B;
+
+ .   47x^2 - 13x - 26 
+
+> A(2);
+
+ .   36 
 \end{verbatim}
 
-Chaque mot est une chaîne de caractères servant à identifier la fréquence associée. Voici un exemple complet de dictionnaire
-et d'utilisation du programme avec ce dictionnaire:
+Comme à la manière MAPLE, il est possible d'évaluer des polynomes en cours de route. Par exemple:
 
 \begin{verbatim}
-Pixel@the-babel-tower:~/Projets_LI/Semestre1/Projet-Algo/src$ cat dict.sample
-MOT1 : 2000
-MOT2 : 1234
-MOT3 : 15987
-MOT4 : 1203
-MOT5 : 192837
-MOT6 : 12987
-Pixel@the-babel-tower:~/Projets_LI/Semestre1/Projet-Algo/src$ ./Huffman -f dict.sample   
-MOT3 (15987) = 00
-MOT1 (2000) = 0100
-MOT4 (1203) = 01010
-MOT2 (1234) = 01011
-MOT6 (12987) = 011
-MOT5 (192837) = 1
-Bitstream length           : 283957 bits (= 35495 bytes)
-Real size input            : 7239936 bits (= 904992 bytes)
-Size squeezed by           : 96.0779 percents
-Dictionnary size           : 336 bits (= 42 bytes)
-Total bitstream length     : 284293 bits (= 35537 bytes)
-Real gain (4 bytes header) : 96.0728 percents
+> P = A + 2*x - 3*B;
+
+ .   x^4 - x^3 + 18x^2 - 2x - 6 
 \end{verbatim}
 
-Il est indiqué que le programme est capable de générer un dictionnaire à partir d'un fichier. Il s'agit simplement de compter
-les caractères provenant de l'entrée et d'en générer un dictionnaire. Exemple:
+Enfin, il y a des appels de fonctions prédéfinis, dont l'appel à la fonction d'évaluation d'un polynôme:
 
 \begin{verbatim}
-$ cat dict.sample | Huffman 
-\32 (12) = 00
-6 (1) = 01000
-4 (2) = 01001
-3 (4) = 0101
-0 (4) = 0110
-5 (2) = 01110
-7 (3) = 01111
-1 (6) = 1000
-M (6) = 1001
-: (6) = 1010
-\10 (6) = 1011
-O (6) = 1100
-8 (3) = 11010
-9 (3) = 11011
-2 (6) = 1110
-T (6) = 1111
-Bitstream length           : 294 bits (= 37 bytes)
-Real size input            : 608 bits (= 76 bytes)
-Size squeezed by           : 51.6447 percents
-Dictionnary size           : 512 bits (= 64 bytes)
-Total bitstream length     : 806 bits (= 101 bytes)
-Real gain (4 bytes header) : -38.1579 percents
+> P(3);
+
+ .   204 
 \end{verbatim}
+
+Le parseur de ligne étant totalement flexible, il est possible de mélanger toutes les fonctionnalités ensembles:
+\begin{verbatim}
+> (2*P + B)(3);
+
+ .   388 
+
+
+>
+\end{verbatim}
\ No newline at end of file