Está en la página 1de 5

INFORME N°1: CODIFICACIÓN Y DECODIFICACIÓN

DE HUFFMAN Y HUFFMAN EXTENDIDO


Facultad de Ingeniería Eléctrica y Electrónica

Abstract: This report aims to publicize one of the símbolos coinciden con las usadas para crear el
best-known compression codes, the operation of the código. Posteriormente se encontró un método
Huffman code and its extended version, this will be para llevar esto a cabo en un tiempo lineal si las
accompanied by its respective programming with the probabilidades de los símbolos de entrada
MatLab program. These codes seek to optimize the
(también conocidas como "pesos") están
maximum bit length per word but maintaining the
ordenadas.
immediacy of the code in order to optimize the
amount of information sent with respect to the bit
Aunque la codificación de Huffman es óptima
rate per second.
para una codificación símbolo a símbolo dada
una distribución de probabilidad, su
optimización a veces puede verse
I. INTRODUCCIÓN accidentalmente exagerada. Por ejemplo, la
codificación aritmética y la codificación LZW
La codificación Huffman es un algoritmo usado
normalmente ofrecen mayor capacidad de
para compresión de datos. El término se refiere
compresión. Estos dos métodos pueden agrupar
al uso de una tabla de códigos de longitud
un número arbitrario de símbolos para una
variable para codificar un determinado símbolo
codificación más eficiente, y en general se
(como puede ser un carácter en un archivo),
adaptan a las estadísticas de entrada reales. Este
donde la tabla ha sido rellenada de una manera
último es útil cuando las probabilidades no se
específica basándose en la probabilidad
conocen de forma precisa o varían
estimada de aparición de cada posible valor de
significativamente dentro del flujo de datos.
dicho símbolo. Fue desarrollado por David A.
Huffman mientras era estudiante de doctorado
en el MIT, y publicado en "A Method for the
Construction of Minimum-Redundancy
Codes".

La codificación Huffman usa un método


específico para elegir la representación de cada
símbolo, que da lugar a un código prefijo (es
decir, la cadena de bits que representa a un
símbolo en particular nunca es prefijo de la
cadena de bits de un símbolo distinto) que
representa los caracteres más comunes usando
las cadenas de bits más cortas, y viceversa. Fig. 1 ejemplo de código Huffman
Huffman fue capaz de diseñar el método de
compresión más eficiente de este tipo: ninguna II. PREGUNTAS A RESOLVER
representación alternativa de un conjunto de
símbolos de entrada produce una salida media 1. Pagina 24 desarrollar los 06 ejercicios
más pequeña cuando las frecuencias de los (2.7 Ejercicios)
EJERCICIO 1: Y deducir razonablemente que el código es
también óptimo para la distribución de
Determinar cuáles de los siguientes códigos probabilidad:
son de codificación única:
1 1 1 1 1
a) 𝐶 = {0,10,11} . . , ,
5 5 5 5 5

Por el principio del prefijo podemos


notar que ningún código en prefijo de -Para la primera distribución de probabilidad se
otro, por lo tanto es un código tiene el siguiente código:
instantáneo y ello conlleva a que sea
𝑎1 : 11
necesariamente de decodificación
única. 𝑎2 : 100

b) 𝐶 = {0,01,11} 𝑎3 : 101

Se trata de un código no instantáneo 𝑎4 : 00


pero de decodificación única. 𝑎5 : 01

c) 𝐶 = {0,01,10} Con lo cual podemos hallar su longitud media:

En este código si se tiene la secuencia 𝐿̅ = 2.4


010 se podría interpretar como símbolo
-Para la segunda distribución de probabilidad se
1 seguido del tercer símbolo o como el
tiene el siguiente código:
segundo símbolo seguido del primero,
por ello no es de decodificación única. 𝑎1 : 00

d) 𝐶 = {110, 11, 100, 00, 10} 𝑎2 : 01

De acuerdo con el criterio de Kraft 𝑎3 : 10


𝐾 = 3 ∗ 2−2 + 2 ∗ 2−3 = 1.75 > 1
𝑎4 : 110
Por lo tanto no puede ser de
𝑎5 : 111
decodificación única
Con lo cual podemos hallar su longitud media:
EJERCICO 2
𝐿̅ = 2.4
Encontrar el código Huffman de :
Debido a que ambas distribución de probabilidad
{𝑎1 , 𝑎2 , 𝑎3 ; 𝑎4 , 𝑎5 }
tienen igual longitud media, son igual de óptimas.

Con probabilidad:
EJERCICIO 3
1 1 1 2 2
, , , ,
3 5 5 15 15
Probar que no existe una codificación binaria 𝑎5 : 10
instantánea para 10 símbolos con longitudes
0,1,2,2,3,3,3,3,4,4 EJERCICIO 6

Primero notar que si un código tiene longitud 0, no Se tiene la fuente con respectiva probabilidad:
es no singular, por lo tanto ya no puede ser
{𝑎1 , 𝑎2 , 𝑎3 ; 𝑎4 , 𝑎5 }
instantánea. Esto se puede notar cuando aplicamos
la fórmula de Kraft: {0.15, 0.04, 0.26,0.05, 0.5}
1 a. Calcular entropía:
𝐾= +⋯
20
La entropía la calculamos de la matriz de
Tan solo el primer término es uno, por ello K será
probabilidades:
mayor que 1, por lo que el código no es instantáneo.

EJERCICIO 4 𝐻 = 1.8177

Se pide código ternario para: b. Encontrar el código Huffman


{𝑎1 , 𝑎2 , 𝑎3 ; 𝑎4 , 𝑎5 }
Aplicando el algoritmo de Huffman se obtiene:
{0.4, 0.3, 0.1,0.1, 0.1}
𝑎1 : 110
Aplicando el algoritmo de Huffman se obtiene:
𝑎2 : 1111
𝑎1 : 0
𝑎3 : 10
𝑎2 : 1
𝑎4 : 1110
𝑎3 : 20
𝑎5 : 0
𝑎4 : 21

𝑎5 : 22

EJERCICIO 5 c. Determinar la longitud media

Se pide código binario para: 𝐿̅ = 1.83

{𝑎1 , 𝑎2 , 𝑎3 ; 𝑎4 , 𝑎5 , 𝑎6 }

1 2 3 4 5 6 2. Pagina 25 desarrollar la programación


{ , , , , , } (2.8 practicas de programación)
21 21 21 21 21 21

Aplicando el algoritmo de Huffman se obtiene: Dados el alfabeto fuente S y la función de


probabilidad P, elaborar un programa de MatLab
𝑎1 : 1110
para determinar un código binario de Huffman y
𝑎2 : 1111 codificar fuente de longitud arbitraria.

𝑎3 : 110 A continuación se muestra el código realizado en


Matlab, el cual será explicado en clase:
𝑎4 : 01
clc,clear Cod = huffmanenco(D,dict)
S = [1 2 3 4 5]; %%Cod = [1 1 0 1 0 1 0 0 0 1 1 0 0 0
P = [.15 .04 .26 .05 .5]; 0 1 0 1 0 1 1 1 0 0 0 1 1 0 1 0 1 1 0
[dict,L] = huffmandict(S,P); 0 0]
L
dict decD = huffmandeco(Cod,dict)
%%matris de celdas de 2 columnas D
%%X = 1:length(S);
for j = 1:length(S) isequal(D,decD)
C = huffmanenco(S(j),dict);
C = C.';
fprintf('código para símbolo %d :
',j); 3. Página 42 desarrollar la programación
fprintf ('%d',C); (3.5 prácticas de programación)
fprintf('\n');
%%x = length(C);
%%X(j) = x;
Dados el alfabeto fuente S y la función de
end probabilidad P, elaborar un programa de MatLab
para determinar un código extendido binario de
Huffman y codificar y decodificar un mensaje
%% fuente de longitud arbitraria.
clc, clear
S = [1 2 3 4 5];
El código desarrollado se encuentra a continuación
P = [.15 .04 .26 .05 .5];
[dict,L] = huffmandict(S,P); y será explicado en clase:

for j = 1:length(S) clc,clear


C = huffmanenco(S(j),dict); S = [1 2 3];
C = C.'; P = [.8 .02 .18];
fprintf('código para símbolo %d : [dict,L] = huffmandict(S,P);
',j); for j = 1:length(S)
fprintf ('%d',C); C = huffmanenco(S(j),dict);
fprintf('\n'); C = C.';
end fprintf('código para símbolo %d :
',j);
fprintf ('%d',C);
D = randsrc(1,10,[S; P]) fprintf('\n');
Cod = huffmanenco(D,dict) %%x = length(C);
%%X(j) = x;
end
L
n = length (S)
%% traP = P.';
clc,clear T = traP*P
S = [1 2 3 4 5]; q = 1;
P = [.15 .04 .26 .05 .5]; M = 1:n^2;
[dict,L] = huffmandict(S,P); for k = 1:n
for l = 1:n
M(q)= T(k,l);
for j = 1:length(S) q = q+1;
C = huffmanenco(S(j),dict); fprintf('probabilidad para
C = C.'; símbolo m%dm%d : ',k,l);
fprintf('código para símbolo %d : fprintf ('%4f',T(k,l));
',j); fprintf('\n');
fprintf ('%d',C);
fprintf('\n');
end end
end
M %%nueva matris de probabilidades
D = randsrc(1,15,[S; P]);
S2 = 1:n^2; n = length (S);
[dict,L2] = huffmandict(S2,M); traP = P.';
L2 T = traP*P;
for j = 1:n^2 q = 1;
M = 1:n^2;
C = huffmanenco(S2(j),dict); for k = 1:n
C = C.'; for l = 1:n
M(q)= T(k,l);
fprintf('el código para símbolo q = q+1;
%d : ',j); fprintf('probabilidad para
fprintf ('%d',C); símbolo m%dm%d : ',k,l);
fprintf('\n'); fprintf ('%4f',T(k,l));
fprintf('\n');
end
%% end
clc,clear end
S = [1 2 3]; S2 = 1:n^2;
P = [.8 .02 .18]; [dict,L2] = huffmandict(S2,M);
fprintf('\n ');
for j = 1:n^2
n = length (S);
traP = P.';
T = traP*P; C = huffmanenco(S2(j),dict);
q = 1; C = C.';
M = 1:n^2;
for k = 1:n fprintf('el código para símbolo
for l = 1:n %d : ',j);
M(q)= T(k,l); fprintf ('%d',C);
q = q+1; fprintf('\n');
fprintf('probabilidad para
símbolo m%dm%d : ',k,l); end
fprintf ('%4f',T(k,l));
fprintf('\n'); D = randsrc(1,10,[S2; M]);
Cod = huffmanenco(D,dict)%% esto es
end lo que decodificaremos
end
S2 = 1:n^2; decD = huffmandeco(Cod,dict)
[dict,L2] = huffmandict(S2,M); D
fprintf('\n ');
for j = 1:n^2 isequal(D,decD)

C = huffmanenco(S2(j),dict);
C = C.';

fprintf('el código para símbolo


%d : ',j);
fprintf ('%d',C);
fprintf('\n');

end

D = randsrc(1,10,[S2; M])
Cod = huffmanenco(D,dict)
%%
clc,clear
S = [1 2 3];
P = [.8 .02 .18];