\documentclass{article}
\input{../../preambule/preambule}

\newcommand{\nom}{TDx : Choix de la fonction de Lyapunov candidate et Commandabilité et Observabilité}
\renewcommand{\nomentete}{UE455 - \nom}



\begin{document}

\titre{\nom}
\section*{Exercice 9: Comparaison de LZM et de LZ77}

On considère une source $\X$ ayant généré le message suivant:
\[bongbonbongobang\$ \]
ou $\$$ est un symbole particulier marquant la fin du message, mais qui devra être codé comme les autres symboles.\\

\begin{enumerate}
\item Trivial

\item très simple

\item easy

\item On confond fréquence et probabilité estimé:
\begin{tabular}{|c|c|}
\hline 
Symboles & Fréquence \\ 
\hline
\hline 
b & $\frac{4}{17}$ \\ 
\hline 
o & $\frac{4}{17}$ \\ 
\hline 
n & $\frac{4}{17}$ \\ 
\hline 
g & $\frac{3}{17}$ \\ 
\hline 
a & $\frac{1}{17}$ \\ 
\hline 
$\$$ & $\frac{1}{17}$ \\ 
\hline 
\end{tabular} 

L'entropie est donc de 2.4 bits/symbole.

\item On initialise le dictionnaire avec 
On commence par coder la première lettre, puis on rajoute la lettre et la lettre suivante au dictionnaire et ainsi de suite.
Lorsque l'on arrive a $bo$ qui est déjà dans le dictionnaire, on peut directement le coder, puis on le rajoute ainsi que la lettre qui suit c'est à dire $bon$, et ainsi de suite.

Le dictionnaire ainsi généré est:
 
 \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|}
   \hline 
   a & b & g & o & n & $\$$ & bo & on & ng &gb & bon & nb & bong & go & ob & ba & an & ng$\$$\\ 
   \hline 
   0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 &9 & 10 & 11 & 12 & 13 & 14 & 15 & 16 & 17\\ 
   \hline 
   \end{tabular}   


La séquence ainsi obtenue est :
\[\text{1 4 3 2 6 3 10 0 4 1 0 8 5}\]

\item Pour décoder, on effectue la même démarche, on décode 1 en d qui est déjà dans le dictionnaire et on ajoute d et la prochaine lettre trouvée et ainsi de suite. 
Si on l'effectue correctement on retrouve le même texte avec le même dictionnaire.

\item Il prend 5 symboles à partir de second. 

\item Problème d'initialisation, il n'est pas possible de coder un symbole qui n'est jamais apparu.

\item A l'itération i, on a $x_1,...,x_n = [y_i,\omega_i, \xi^{(i)},z_i]$ avec $y_i$ qui est déjà codé, $\omega_i$ la plus longue sous chaine de $y_i$ et $\xi^{(i)}$ le symbole suivant $\omega_i$.\\
Ainsi $[\omega_i , \xi_{(i)}]$ est codé $ <j, k, \xi_{(i)}>$.\\
Si $\omega_i = 0$ on code $ <0, 0, \xi_{(i)}>$.

ET on oublie pas : $c(i,:) = <j, k, \xi_{(i)}>$, c'est à dire: ??!?. Ça traine tout seul dans son coin du tableau.

\item Pour coder la chaîne bongbonbongobang$\$$, on commence par coder les quatre premiers symboles, c'est à dire que l'on a:
\[<0,0<b> <0,0,o> <0,0,n> <0,0,g>\]
Puis on code les quatre suivant ensemble avec $<1,3,b>$ car la sous-chaine composé de $bon$ apparait déjà avant.\\
Puis $ongo$ car la racine $ong$ existe déjà donc on a $<2,3,o>$.\\
Ensuite on code $ba$ qui donne $<1,1,a>$.\\
Et pour finir on code $ng\$$ qui donne $<3,2,\$>$.


\item \begin{lstlisting}
c; //vecteur de triples
x  = []; // séquence décodée
for i=1:length(c)
	x = [x, x[c(i,1):c(i,1)+c(i,2)], c(i,3)]
end
\end{lstlisting}

\item Pour coder la chaîne bongbonbongobang$\$$, on commence par coder les quatre premiers symboles, c'est à dire que l'on a:
\[<0,0<b> <0,0,o> <0,0,n> <0,0,g>\]
Puis on code les quatre suivant ensemble avec $<1,3,b>$ car la sous-chaine composé de $bon$ apparait déjà avant.\\
Puis $ongo$ car la racine $ong$ existe déjà donc on a $<2,3,o>$.\\
Ensuite on code $ba$ qui donne $<1,1,a>$.\\
Et pour finir on code $ng\$$ qui donne $<3,2,\$>$.

\item On effectue le même travail en décodant cette fois. Si on ne se trompe pas, on retombe sur la même chose.

\item Avec la méthode C, pour coder bongbongbonbongobang$\$$ on obtient:
$<0,0,b> ... <0,0,g> <1,7,b><2,3,o><1,1,a><3,2,\$>$
Ce que l'on retient c'est que pour bongbon on a une répétition sur 7 symbole des 4 premiers, après il suffit d'appliquer bêtement l'énoncé.

\item \begin{lstlisting}
c; 
x=[];
for i=1:length(c)
	for j = 1:c(i,2)
		x = x[x,x[c(i,1+j-1)];
	end
end
\end{lstlisting}

LE problème est que ?  pas compris ce qu'il a dit.

\item \begin{align*}
0 \leq j \leq s \Rightarrow \lceillog_2 S \rceil \text{ bits} \\
0 \leq k \leq s + t \Rightarrow \lceillog_2 (S+t) \rceil \text{ bits} \\
u \Rightarrow \lceillog_2 u \rceil \text{ bits} \\
\end{align*}





\end{enumerate}



\end{document}