Trabajo de Lapo

UNIVERSIDAD NACIONAL DE LOJA
Área De Energía, Las Industrias y Recursos Naturaleza No

Renovables
CARRERA DE INGENIERÍA EN
TELECOMUNICACIONES
TEORÍA DE LA INFORMACIÓN
PROYECTO FINAL
DISEÑO DEL ARBOL Y PROGRAMACION DE LA
CODIFICACION DE HUFFMAN EN MATLAB.
ESTUDIANTE
 Jhonatan Paul Lapo Chuquimarca
CICLO: CUARTO TELECOMUNICACIONES

DOCENTE RESPONSABLE:
Ing. Santiago Abraham Medina León. Mg. Sc
Loja – Ecuador
2021
Contenido
1. ANTECEDENTES.............................................................................................................5
2. JUSTIFICACION..............................................................................................................7
3. OBJETIVOS.......................................................................................................................8
3.1. OBJETIVO GENERAL....................................................................................................8
3.2. OBJETIVOS ESPECIFICOS............................................................................................8
4. METODOLOGIA..............................................................................................................9
4.1 INVESTIGACION.............................................................................................................9
4.2 CONOCIMIENTOS...........................................................................................................9
4.3 PROCEDIMIENTOS.........................................................................................................9
5. CONTENIDO TEMATICO............................................................................................10
5.1 INTRODUCCION...........................................................................................................10
5.2 MATLAB.........................................................................................................................11
5.3 GUIDE.............................................................................................................................11
5.4 PUSH BUTTON..............................................................................................................12
5.5 EDIT TEXT.....................................................................................................................13
5.6 STATIC TEXT.................................................................................................................14
5.7 AXES...............................................................................................................................14
5.8 CALLBACK....................................................................................................................15
5.9 FUNCTION......................................................................................................................15
5.10 READTABLE................................................................................................................15
5.11 SPLIT (STR, DELIMETER)..........................................................................................16
5.12 UNIQUE........................................................................................................................16
5.13 [Lia, Locb] = ismember (__)..........................................................................................16
5.14 ACCUMARRAY...........................................................................................................16
5.15 FOR................................................................................................................................17
5.16 NUM_BITS....................................................................................................................17
5.17 WHILE...........................................................................................................................17
5.18 TREEPLOT....................................................................................................................18
5.19 CODIFICACION DE HUFFMAN.................................................................................18
5.20 ARBOL DE HUFFMAN................................................................................................19
5.21 FRECUENCIA DE LETRAS EN ESPAÑOL................................................................20
6. CONCLUSIONES Y RECOMENDACIONES..............................................................22
CONCLUSIONES.................................................................................................................22
RECOMENDACIONES........................................................................................................23
7. REFERENCIAS...............................................................................................................23
2
8. ANEXOS...........................................................................................................................24
8.1 MANUAL DEL PROGRAMADOR..........................................................................24
8.2 MANUAL DEL USUARIO......................................................................................35
9. VITA..................................................................................................................................38
10. CODIGO DEL PROGRAMA.........................................................................................39
INDICE DE TABLAS
INDICE DE FIGURAS
1. ANTECEDENTES
Tomando como referencia la historia de la codificación de códigos o sobre su

principal personaje David Albert Huffman el cual protagonizo este
descubrimiento importante sobre la codificación de códigos.
Entre la historia de la codificación de códigos tenemos: la codificación de
SHANNON-FANO como previa codificación de código y en base de mejorar
este se desarrolló una mejor codificación de código la cual lleva por si su
nombre y es la codificación de HUFFMAN.
La codificación de SHANNON-FANO fue desarrollada por Claude Shannon
(1916-2001) fundador del campo de la teoría de la información y de haber
asentado las bases de la teoría del diseño de circuitos digitales y Roberto Mario
Fano (1917-2016) conocido por sus trabajos sobre la teoría de la información,
desigualdad de Fano, algoritmo de Fano y métrica de Fano. Aproximadamente
en 1960 habían desarrollado un procedimiento de codificación para generar un
árbol de código binario. El procedimiento evalúa la probabilidad del símbolo y
3
asigna palabras de código con una longitud de código correspondiente.[ CITATION
Int07 \l 12298 ]
La codificación de Shannon-Fano es fácil de implementar, en la operación la
codificación de Shannon-Fano no es de mayor importancia esto se debe
especialmente a la menor eficiencia del código en comparación con la
codificación de Huffman. Su principal uso es en aplicar un algoritmo simple con
alto rendimiento y requisitos mínimos para la programación. [ CITATION Int07 \l
12298 ]
David Albert Huffman nacido en Ohio el 9 de agosto de 1925, obtuvo su
licenciatura en ingeniería eléctrica de la universidad estatal de Ohio a la edad de
18 en 1944. Posteriormente obtuvo su maestría en Ohio 1949 y su PhD del MIT
en 1953. [ CITATION Ins21 \l 12298 ]
Huffman hizo importantes contribuciones en muchas otras áreas, incluida la
teoría y la codificación de la información, el diseño de señales para aplicaciones
de radar y comunicaciones y los procedimientos de diseño para circuitos lógicos
asíncronos. Como resultado de su trabajo sobre las propiedades matemáticas de
las superficies de "curvatura gaussiana cero", Huffman desarrolló sus propias
técnicas para doblar papel en formas esculpidas inusuales (que dieron lugar al
campo del origami computacional).[ CITATION Ins21 \l 12298 ]
Desarrollo también el procedimiento de codificación Huffman mientras se
encontraba como estudiante en el MIT. El “código de Huffman” está presente
hoy en día en casi todas las aplicaciones que precisan de un sistema eficiente de
representación de información de código binario.[ CITATION Jos03 \l 12298 ]
El algoritmo descrito por David Huffman asigna a cada símbolo a un nodo hoja
de un árbol de código binario estos nodos están ponderados por el número de
apariciones del símbolo correspondiente llamado frecuencia costo. [ CITATION
Int07 \l 12298 ]
La estructura de árbol es el resultado de combinar los nodos paso a paso hasta
que todos se incrustan en un árbol raíz. El algoritmo siempre combina los dos
nodos que proporcionan la frecuencia más baja en un procedimiento de abajo
hacia arriba. Los nuevos nodos interiores obtienen la suma de las frecuencias de
ambos nodos secundarios. Las ramas del árbol representan los valores binarios
(1,0) y de acuerdo con las reglas para arboles de códigos libre de prefijos
4
comunes. La ruta desde el árbol raíz hasta el nodo hoja correspondiente definen
la palabra de código particular.[ CITATION Int07 \l 12298 ]
2. JUSTIFICACION
El planteamiento de este proyecto fue de describir el diseño del árbol y la

codificación Huffman mediante un algoritmo de MATLAN, teniendo como base
los conceptos y temas adquiridos en la materia de teoría de la información de ahí
el punto de vista sobre la codificación de códigos se tendrá que tener en cuenta
que la codificación Huffman es un algoritmo que soluciono la mayor parte de los
errores en el algoritmo de codificación Shannon-Fano. La solución de este se
basaba en el proceso de construir el árbol de abajo a arriba en vez de, arriba
hacia abajo.
Se buscara abarcar dentro del código de programación toda la lógica necesaria
para cumplir con las soluciones requeridas por el usuario, esto con la ayuda de
conceptos y fundamentos de programación en MATLAB, además se buscara
crear una interfaz gráfica que sea fácil de entender para el usuario ya que existen
un sin número de programas que debido a su poco intercambio usuario-
5
programa los hace difícil de entender llegando al problema de no entender la
codificación de Huffman y lo que trato de solucionar con su algoritmo.
3. OBJETIVOS
3.1. OBJETIVO GENERAL
Crear un programa que permita al usuario interaccionar con la codificación

Huffman y de obtener el diseño del árbol de código teniendo como entrada la
palabra que ingrese el usuario.
3.2. OBJETIVOS ESPECIFICOS
Implementar los conocimientos sobre codificación de Huffman dentro del

programa para verificar su funcionamiento.
Obtener una interfaz amigable y de fácil manejo para que el usuario pueda
ingresar las palabras y así obtener el diseño del árbol.
6
4. METODOLOGIA
Para poder lograr con nuestros objetivos planteados para el presente proyecto
utilizaremos una gran variedad de métodos y herramientas que nos faciliten la
creación e implementación del proyecto los cuales son:
4.1 INVESTIGACION
Investigamos las opciones que teníamos para trabajar nuestro proyecto como
son: la plataforma de Guide, librerías, lenguaje de programación en Matlab. Lo
cual se trató de buscar las herramientas más accesibles y de fácil manejo al
momento de programar.
Se investigo acerca de cómo trabajar con la interfaz Guide de Matlab, su

funcionamiento y el conocer su estructura, esto tomando como base algunos
ejemplos ya realizados y previsualizados con lo cual se obtuvo una guía para
crear nuestro interfaz.
7
Investigamos datos ya planteados acerca de programas similares, lo que
buscamos con esto es tener la mayor información posible de como plantear
nuestro programa
4.2 CONOCIMIENTOS
Tener claro temas como: características y creación del código de Huffman,
implementación y funcionalidad del árbol de Huffman, comportamiento de las
condiciones que trata Huffman de demostrar, conceptos básicos como códigos
de Shannon-Fano, etc.
Tener conocimientos y bases acerca de programación ya previsualizadas

mediante su análisis y estudio del programa en sí mismo.
4.3 PROCEDIMIENTOS
Primeramente, ya teniendo todo el conocimiento necesario para introducirse de
lleno a trabajar en el proyecto establecido se vio como algo fundamental realizar
el respectivo cronograma el cual ayudara a tener una organización, y poder
verificar los avances que se tiene con el proyecto, así planteándose cada semana
un objetivo que cumplir.
Con la información ya investigada se decidió realizar el prediseño del interfaz ya

que esto es lo que observará y manipulará el usuario, teniendo como objetivo
que sea claro y conciso, esto para que el usuario no tenga mayor problema al
momento de trabajar con el programa.
Se procedió a la construcción del interfaz trabajando con Guide, esto basándose

en ejemplos ya realizados fuimos construyendo nuestro interfaz de la mano del
código que permita lograr una objetividad clara del interfaz.
Ya teniendo nuestro interfaz establecido, se comienza a trabajar con la lógica del

programa en este caso se inició programando y verificación de cada elemento
que lleva este acerca de la codificación de Huffman y su respectivo árbol, esto se
lo hico implementando el conocimiento ya adquirido en la materia de teoría de
la información la cual nos ayuda a comprobar si lo realizado es correcto y si es
necesario ir modificando cada parámetro de este mismo.
Igualmente, con mucha ayuda del material propuesto en internet específicamente

Mathworks, se comienza a trabajar en la creación del algoritmo de Huffman,
8
esto teniendo en cuenta muchos conceptos ya adquiridos en la materia de teoría
de la información y referencias del programa que se utiliza para este proyecto.
5. CONTENIDO TEMATICO
5.1 INTRODUCCION
Este informe reúne diversos conceptos aprendidos en la materia de teoría de la
información y programación aplicada, los cuales son necesarios tener en cuenta
a lo largo de nuestro camino profesional, por medio de este proyecto se busca
enlazar todos esos conocimientos para crear un programa que ayude al usuario a
crear un árbol de Huffman con las frecuencias de las letras más usadas en el
idioma del español tomando en cuenta que dichas frecuencias tienen su
respectiva probabilidad de uso y también estas mismas basando en el libro de la
REGENTA el cual establece la frecuencias de cada letra y signo usado en este
mismo estas probabilidades también se las verifico en el libro de Secret and
Urgent - The Story of Codes and Ciphers esto nos llevó a una conclusión de
cómo utilizar las herramientas que contamos en el programa de Matlab y
también las herramientas de la materia misma.
5.2 MATLAB
Programa basado en matemáticas, gráficos, programación y otras opciones más
nos permite realizar un análisis de datos como desarrolladores de algoritmos o
creadores de modelos, Matlab se ha diseñado para una interacción más profunda
con el programador y el programa.
Este mismo combina un entorno de escritorio perfeccionado para el análisis

iterativo y los procesos de diseño con un lenguaje de programación que expresa
las matemáticas de matrices y arrays directamente.
9
Ilustración 1. Logo de Matlab
5.3 GUIDE
Crear o editar un archivo de interfaz de usuario en GUIDE. Es un entorno de
diseño de interfaz de usuario, desde el cuadro de diálogos de inicio rápido se
puede elegir abrir una interfaz de usuario creada anteriormente o crear una nueva
usando las plantillas predeterminadas.
10
Ilustración 2. Pantalla de Inicio de GUIDE.
Ilustración 3. Pantalla de GUIDE y sus respectivas herramientas.
5.4 PUSH BUTTON

Un botón “push button” genera una acción cuando se presiona por ejemplo un
botón Ok puede cerrar una caja de dialogo y aplicar los ajustes. Cuando se
presione con el mouse un botón “push button” se observa deprimido mientras
que cuando se libera el mouse el boto “push button” no regresa un valor ni
mantiene un estado.
En el GUIDE de la ilustración del botón “push Button” es el que aparecerá.
11
Ilustración 4. Ilustración del botón de pulsar.
5.5 EDIT TEXT
Los controles “edit text” despliega líneas de teto editables. El botón “edit text”
usualmente se utiliza para ajustar con capturar la propiedad “String”, con el
ajuste se despliega el nuevo valor de la propiedad y con la captura es posible el
procesamiento de la información dentro del código. Es decir que el usuario
puede cambiar su texto interactivamente porque existe la forma de invocar la
rutina callback asociada con esta misma.
Ilustración 5. Del cuadro de texto editable en Guide.
5.6 STATIC TEXT

Los controles static text despliegan líneas de texto. El botón “static text”
usualmente se utiliza para colocar la etiqueta de otros controles, suministrar
directrices al usuario no puede cambiar su texto interactivamente y no existe una
forma de invocar la rutina callback asociada con esta mismo.
12
Ilustración 6. Texto estático, herramienta en Guide.
5.7 AXES
Axes crea los ejes cartesianos predeterminados en la figura actual y los convierte
en los ejes actuales. Por lo general, no es necesario crear ejes antes de trazar, ya
que las funciones gráficas crean ejes automáticamente al trazar si no existen.
Ilustración 7. Herramienta de Guide para graficar.

Completada la primera etapa sobre la instalación y distribución de los
componentes de GUIDE, la segunda etapa consiste en la codificación, en el
archivo punto eme de Matlab, de las funciones de cada uno de los botones.
Abierta la interfaz se puede proceder a la programación de cada herramienta que

hemos utilizado en Guide, además de insertar la programación del algoritmo de
Huffman con sus respectivas funciones y comandos que se necesitan para su
funcionamiento.
5.8 CALLBACK
Es una propiedad importante en la que especifica el “callback” o código que se
ejecuta cuando el usuario activa el botón. Cuando se añade por primera vez un
componente al GUIDE, la propiedad “callback” es ajustada al valor de caracteres
“codificación_huffman”. Por defecto, se puede observar, que cuando se instala
por primera vez un botón “Push Button” se le asigna como leyenda genérica el
nombre “pushbutton1_Callback” y para el caso del archivo
“codificación_huffman se optó por dicha denominarlo con otro nombre.
13
5.9 FUNCTION
function [y1, ..., yN] = myfun (x1, ..., xM) declara una función denominada
myfun que acepta entradas x1, ..., xM y devuelve salidas y1, ..., yN. Esta
instrucción de declaración debe ser la primera línea ejecutable de la función. Los
nombres de función válidos empiezan por un carácter alfabético y pueden
contener letras, números o guiones bajos.
Puede guardar su función:
 En un archivo de función que solo contenga definiciones de función. El

nombre del archivo debe coincidir con el nombre de la primera función
del archivo.
 En un archivo de script que contenga comandos y definiciones de
función. Las funciones deben estar al final del archivo. Los archivos de
script no pueden tener el mismo nombre que una función del archivo. Las
funciones se admiten en scripts en la versión R2016b o posterior.
5.10 READTABLE
T = readtable(filename) crea una tabla leyendo datos orientados a columnas de
un archivo.
readtable determina el formato de archivo a partir de la extensión del archivo:
 .txt, .dat, or .csv para archivos de texto delimitados.

 .xls, .xlsb, .xlsm, .xlsx, .xltm, .xltx, or .ods para los archivos de hojas de
cálculo.
readtable crea una variable T para cada columna del archivo y lee los nombres
de las variables de la primera fila del archivo. De forma predeterminada, crea
variables que tienen tipos de datos que son apropiados para los valores de datos
detectados en cada columna del archivo de entrada, readtable.
5.11 SPLIT (STR, DELIMETER)

newStr = split (str, delimiter) divide cada elemento de stren los delimitadores
especificados por delimitar. La salida newStr no incluye los delimitadores.
14
5.12 UNIQUE
Valores únicos en array. C = unique (A) devuelve los mismos datos que en A,
pero sin repeticiones. C está en orden ordenada.
 Si A es una tabla o un calendario, unique devuelve las filas únicas de A

en orden ordenada. Para los horarios, unique toma en cuenta los tiempos
de fila y los valores de fila al determinar si las filas son únicas y ordena
el horario de salida C por tiempos de fila.
5.13 [Lia, Locb] = ismember (__)

[Lia, Locb] = ismember (___) también devuelve una matriz, utilizando
cualquiera de las sintaxis anteriores. Locb
 Generalmente, contiene el índice más bajo para cada valor del que es
miembro. Los valores de indican de dónde no es miembro.
LocbBAB0AB
 Si 'rows' se especifica la opción, entonces contiene el índice más bajo
para cada fila en que también es una fila. Los valores de indican dónde
no es una fila de. LocbBAB0AB
 Si Ay Bson tablas o horarios, entonces contiene el índice más bajo para
cada fila que también es una fila. Los valores de indican dónde no es una
fila de. LocbBAB0AB
5.14 ACCUMARRAY
A = accumarray (subs, val) devuelve array A por elementos de acumulación de
vector val utilizando los subíndices subs. Si subs es un vector de columna,
entonces cada elemento define un subíndice correspondiente en la salida, que
también es un vector de columna. La accumarray función recopila todos los
elementos val que tienen subíndices idénticos subs y almacena su suma en la
ubicación A correspondiente a ese subíndice (for index i,
A(i)=sum(val(subs(:)==i))). Los elementos A cuyos subíndices no aparecen en
subs son iguales a 0.
Para una matriz m-por-n, cada fila representa un subíndice n-dimensional en la

salida A. La i-ésima fila le corresponde al i-ésimo elemento del vector val.
15
5.15 FOR
for index = values, statements, end ejecuta un grupo de instrucciones en un bucle
un número especificado de veces. Values tiene una de las siguientes formas:
initVal: endVal: incrementa la variable index de initVal a endVal en 1 y repite la

ejecución de statements hasta que index es superior a endVal.
initVal: step: endVal: incrementa index según el valor de step en cada iteración o
disminuye index cuando step es negativo.
valArray: crea un vector de columna, index, a partir de las columnas posteriores

del array valArray en cada iteración. Por ejemplo, en la primera iteración, index
= valArray(:,1). El bucle se ejecuta un máximo de n veces, donde n es el número
de columnas de valArray, dado por numel (valArray (1,:)). La entrada valArray
puede ser de cualquier tipo de datos de MATLAB®, como por ejemplo un
vector de caracteres, un array de celdas o una estructura.
5.16 NUM_BITS
Calcula el número de bits con los que codificar. En un sistema binario, se
necesitan n bits para codificar 2 ^ n elementos, por lo que el número de bits a
usar en el codificador Huffman es simplemente el log-base2 del número de
elementos a codificar.
num_bits = ceil(log2(length(prob_dist)))
5.17 WHILE
while expression, statements, end evalúa una expresión y repite la ejecución de
un grupo de instrucciones en un bucle mientras que la expresión es verdadera.
Una expresión es verdadera cuando su resultado no está vacío y contiene solo
elementos no nulos (numéricos reales o lógicos). De lo contrario, la expresión es
falsa.
5.18 TREEPLOT
treeplot(p)traza una imagen de un árbol dado un vector de punteros principales,
con p(i)= 0 para una raíz.
16
Ilustración 8. Grafica de un árbol con el comando treeplot(p).
5.19 CODIFICACION DE HUFFMAN

La codificación de Huffman es un método propuesto en 1952 por David
Huffman. Corresponde a la creación de una tabla de códigos de longitud variable
para codificar cada uno de los símbolos de la fuente, en donde la longitud de los
códigos y la creación de la tabla de codificación dependen de la probabilidad de
cada símbolo. El alfabeto y la distribución de probabilidades de la información
codificada debe ser almacenada y/o enviada al decodificador, para que éste,
logre construir el árbol de Huffman equivalente y así obtener los datos
originales.[ CITATION Yul16 \l 12298 ]
17
Tabla 1. Tabla de códigos de longitud variable para codificar
La codificación de Huffman es un algoritmo esencial en la compresión de datos,

es el área de conocimiento que se dedica a reducir el número de bits necesarios
para representar la información.[ CITATION Yul16 \l 12298 ]
También es utilizada en numerosas ocasiones para comprimir cadenas de bits

que representan texto y desempeña un papel fundamental en la compresión de
archivos de audio y de imágenes. [ CITATION Yul16 \l 12298 ]
5.20 ARBOL DE HUFFMAN

Un árbol binario en el que cada hijo de un vértice se designe como hijo izquierdo
o hijo derecho ningún vértice esta etiquetado con una clave que es uno de los
objetos. Además, a los vértices se le designan las claves de modo que la clave de
un vértice es mayor que la de todos los vértices de subárbol izquierdo y menor
que la de todos los vértices de subárbol derecho.[ CITATION Est16 \l 12298 ]
Ilustración 9. Árbol de Huffman.
18
5.21 FRECUENCIA DE LETRAS EN ESPAÑOL
El análisis y cálculo de la frecuencia de letras como signos en una legua es
difícil y esto debido a su interpretación. Se cuenta la frecuencia de las letras de
un texto arbitrariamente largo como “La regenta” debido a su uso de letras y
signos en el español se tomó en cuenta sus tablas de frecuencias como indicación
para el programa debido al uso frecuente y repetición de las todas las letras del
alfabeto español.
T Fre
a cue Frec.rel
b ncia %
l
a
2
.
T
a
b
l
a
d
e
f
r
e
c
u
e
n
c
i
a
s
“
19
L
a
r
e
g
e
n
t
a
”
d
e
l
e
t
r
a
s
y
s
i
g
n
o
s
e
n
e
l
e
s
p
a
ñ
20
o
l.
S
i
g
n
o
e 305 1
s 290 7
p ,
a 5
ci 9
o 9
a 186 1
459 0
,
7
4
9
e 171 9
111 ,
8
6
4
o 119 6
217 ,
8
7
2
s 101 5
317 ,
8
4
1
r 892 5
21
43 ,
1
4
5
n 875 5
85 ,
0
4
9
l 835 4
24 ,
8
1
5
i 687 3
91 ,
9
6
6
d 672 3
15 ,
8
7
5
u 562 3
87 ,
2
4
5
t 539 3
37 ,
1
0
9
c 523 3
46 ,
22
0
1
8
m 365 2
00 ,
1
0
4
p 339 1
70 ,
9
5
8
b 266 1
58 ,
5
3
7
. 260 1
79 ,
5
0
3
, 244 1
47 ,
4
0
9
q 177 1
73 ,
0
2
5
í 174 1
93 ,
0
23
0
8
v 154 0
91 ,
8
9
3
g 152 0
02 ,
8
7
6
h 137 0
96 ,
7
9
5
y 136 0
19 ,
7
8
5
ó 879 0
2 ,
5
0
7
f 845 0
4 ,
4
8
7
j 642 0
8 ,
3
7
24
1
á 620 0
7 ,
3
5
8
z 554 0
9 ,
3
2
é 514 0
1 ,
2
9
6
; 365 0
8 ,
2
1
1
ñ 350 0
1 ,
2
0
2
ú 128 0
6 ,
0
7
4
x 122 0
4 ,
0
7
1
: 941 0
25
,
0
5
4
ü 89 0
,
0
0
5
k 59 0
,
0
0
3
w 20 0
,
0
0
1
También analizando sobre libros de criptografía cifrada y sus tablas de

frecuencias de letras, pero sin signos se llegó analizar y comparar las tablas para
dar una nueva visión sobre su uso, como resultado se obtuve que las frecuencias
en las letras variaban por porcentajes debido a que esta tabla no tenía ningún
signo de puntuación, ni tampoco el espacio.
26
Tabla 3. Tabla de frecuencias de letras en español de criptografía.
Tomando todos estos análisis se llegó a la conclusión de que la tabla de la “La

regenta” es la más adecuada para este programa.
Nota: como último análisis se pudo concluir que para mejorar el programa sería
mejor utilizar el código ASCII ya que este es universal en el lenguaje de la
máquina.
6. CONCLUSIONES Y RECOMENDACIONES
CONCLUSIONES
Se logro crear un programa que permita al usuario obtener el árbol y
codificación de Huffman, teniendo como único ingreso la palabra o palabras que
el usuario valla a ingresar, por lo tanto, se disminuye el tiempo en que el usuario
tenía que ingresar más datos.
Este proyecto cumple con la función principal de crear un árbol de Huffman
mediante programación y funciones internas de Matlab.
27
Se busco generar una interfaz gráfica acorde al programa, de modo que el
usuario si tiene dudas sobre que es la codificación de Huffman y el árbol de
Huffman se le implemento un menú de ayuda para que este consulte.
RECOMENDACIONES
Trabajar en sincronía con el cronograma establecido al inicio del proyecto fue
fundamental para ir cumpliendo con todas las actividades planteadas, con esto se
evitó retrasos y aglomeraciones de trabajo al final.
Realizar una investigación previa sobre el programa y de algunos ejemplos
similares al proyecto, que se encuentran en internet sirvió como base y guía al
momento de ir construyendo el programa. Además, tener claro los contenidos
teóricos de programación y de la materia de Teoría de la información.
Presentar un interfaz grafico que sea entendible para el usuario, con esto se
evitara problemas al momento de su manipulación.
Tener en consideración que cuando se trabaja, es recomendable tener dividido el
programa por partes y comentada ya que este mismo puedo sufrir alguna
alteración o perdida de datos para su funcionamiento.
7. REFERENCIAS
Engineers, I. o. (2021). IEEE.org. Obtenido de
https://www.computer.org/profiles/david-huffman
Internet Archive . (21 de Agosto de 2007). Obtenido de
https://web.archive.org/web/20070821221604/http://www.binaryessence.
com/dct/en000041.htm
Mina, E. A. (23 de 05 de 2016). Universidad del Valle. Obtenido de
https://www.slideshare.net/estediaz/grafos-92-2016
Ocampo, Y. C. (18 de 05 de 2016). Codificacion Huffman Mejorada con
Cifrado Datos. Obtenido de
https://d1wqtxts1xzle7.cloudfront.net/52587439/Codificacion-huffman-
mejorada.pdf?1491958458=&response-content-disposition=inline
%3B+filename
%3DCodificacion_Huffman_Mejorada_con_Cifrad.pdf&Expires=16139
48224&Signature=fdXt5yjvGxvt~IarV4ptSuZ5aYfc9GCygFGlao
Prieto, J. L. (14 de Octubre de 2003). Glosario Terminologia Informatica.
Obtenido de http://www.tugurium.com/gti/termino.php?Tr=Huffman
%2C%20David%20Albert&Tp=P&Or=0
28
29
8. ANEXOS
30
8.1 MANUAL DEL PROGRAMADOR
6
3
5
4
Ilustración 10. Manual del Programador Anexo 1.
1. Ventana de inicio del programa de Matlab

2. New script: para crear un nuevo script
3. Editor: donde se podrá iniciar la programación del programa que se va a
realizar.
4. Workspace:
5. Command Window:
6. Current folder:
31
7. En command window se escribira guide para iniciar el diseño de la

interfaz
8. Blank GUI(Default): se selecionara para iniciar con la creación de Guide.

9. Aquí se selecciona la carpeta donde contendrá nuestros archivos y
también se activará el cuadro de dialogo para guardar todos los cambios
que se realice en este misma.
32
16
15
13
10
12
14
11
Ilustración 13. Manual del Programador Anexo 4
.
10. Herramientas de Guide.
11. Push button: esta herramienta se utilizará para crear un botón.
12. Edit text: se utilizará para poner un cuadro de texto estático en la
interfaz.
13. Herramientas para crear menús de ayuda.
14. Axes: donde se podrá visualizar las figuras de la programación.
15. En esta opción podremos guardar todo el avance de la Guide.
16. En esta opción podremos visualizar como va quedando nuestra interfaz
en Guide
17
18
33
17. Menú de edición de las características de los botones, este menú aparece
pulsando dos veces clic izquierdo en cualquier herramienta de Guide que
desee editar sus propiedades.
18. String: en este apartado podremos editar los nombres de las herramientas
de Guide.
19

19. Pulsando clic derecho en cualquier botón que se haya creado en Guide
apareceré este menú donde nos llevara a varias opciones, seleccionamos
view callback luego callback y hacemos clic derecho en esta opción
donde nos llevara al editor de Matlab donde podremos editar la
programación del programa.
34
20

20. Esta en la ventana del editor de la programación del programa. En editor
procederemos a construir el algoritmo de nuestro programa de
codificación de Huffman.
21
35
21. En este apartado cargaremos nuestra imagen que va a servir como fondo
de pantalla y también cargaremos la hoja de Excel con las frecuencias
que se van a utilizar en el programa.
22. En este apartado ya empezamos con la programación de cada objeto que
se va a utilizar en el programa. Comenzando con la imagen de fondo de
pantalla de nuestro interfaz.
23. Esta programación nos permitirá poner fondo de pantalla a nuestra
interfaz como lo indica la siguiente ilustración.
23

24. En la function edit1_Callback ingresaremos la programación de la
codificación de Huffman.
24
36
25. Ingreso de las palabras del usuario

26. Lectura del archivo de Excel en Matlab y su respectivo análisis de prob.
25
26

27. Inicio del análisis de la codificación de Huffman
28. Inicio de la matriz de codificación
29. Proceso de codificación de Huffman
37
28
29

30. Formulario de datos del árbol de Huffman
31. Cálculos de los parámetros del árbol
32. Traza el árbol de Huffman
38
30
31
32

33. Símbolos del árbol y sus probabilidades
34. Extracción de parámetros del árbol
35. Cálculo del libro de Huffman
39
33
34
35

36. Salida de la consola-Libro de códigos de Huffman
36

37. Parte del código donde se podrá graficar en exes3
40
37

38. Función donde se podrá cargar archivos pdf a nuestro menú de ayuda.
38
41
8.2 MANUAL DEL USUARIO
El presente manual de usuario está organizado de acuerdo al procedimiento
que deber seguir el usuario para obtener los resultados deseados.
1. Ventana de ejecución del programa.
Ilustración 27. Manual del Usuario Anexo 18.

2. Ingreso de los datos del usuario
3. Botón para calcular
4. Botón para limpiar
3 4
42
5. Menú de ayuda para el usuario.

6. Parte donde se va graficar nuestro árbol de Huffman.
7. Parte donde se podrá visualizar el código de Huffman.
43
7
8. Funcionamiento del programa.
44
9. VITA
Autor: Jhonatan Paul Lapo Chuquimarca
Nació el 20 de noviembre de 1995, estudio la primaria en el centro educativo

maravillas del saber en la cuidad Quito, estudio en el colegio Andrés F. Córdova
durante un culmino su bachillerato en el colegio técnico Vida nueva, la
educación superior la curso en la Universidad politécnica Salesiana durante unos
ciclos y actualmente se encuentra estudiando en la Universidad Nacional de Loja
la carrera de Telecomunicaciones, donde es miembro del club de Robótica en la
cual ha contribuido a la creación de diversos proyectos.
45
10. CODIGO DEL PROGRAMA
A continuación, se presenta las partes más importantes del código.
Todos estos contenidos se encentran en la carpeta ejecutable árbol de Huffman

que guarda toda la información con respecto a nuestra programación, archivos
necesarios para este programa, esta carpeta es editable y se la puede trabajar de
una manera eficiente.
function varargout = Codigo_Huffman(varargin)

% CODIGO_HUFFMAN MATLAB code for Codigo_Huffman.fig
% CODIGO_HUFFMAN, by itself, creates a new CODIGO_HUFFMAN or
raises the existing
% singleton*.
%
% H = CODIGO_HUFFMAN returns the handle to a new CODIGO_HUFFMAN
or the handle to
% the existing singleton*.
%
% CODIGO_HUFFMAN('CALLBACK',hObject,eventData,handles,...) calls
the local
% function named CALLBACK in CODIGO_HUFFMAN.M with the given
input arguments.
%
% CODIGO_HUFFMAN('Property','Value',...) creates a new
CODIGO_HUFFMAN or raises the
% existing singleton*. Starting from the left, property value
pairs are
% applied to the GUI before Codigo_Huffman_OpeningFcn gets
called. An
% unrecognized property name or invalid value makes property
application
% stop. All inputs are passed to Codigo_Huffman_OpeningFcn via
varargin.
%
% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows
only one
% instance to run (singleton)".
%
% See also: GUIDE, GUIDATA, GUIHANDLES
% Edit the above text to modify the response to help Codigo_Huffman
% Last Modified by GUIDE v2.5 22-Feb-2021 11:11:31
% Begin initialization code - DO NOT EDIT

gui_Singleton = 1;
gui_State = struct('gui_Name', mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @Codigo_Huffman_OpeningFcn, ...
'gui_OutputFcn', @Codigo_Huffman_OutputFcn, ...
'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end
46
if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT
% --- Executes just before Codigo_Huffman is made visible.

function Codigo_Huffman_OpeningFcn(hObject, eventdata, handles,
varargin)
% This function has no output args, see OutputFcn.
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% varargin command line arguments to Codigo_Huffman (see VARARGIN)
a=imread('Imagen1.jpg');
image(a)
axis off
grid off
% Choose default command line output for Codigo_Huffman
handles.output = hObject;
% Update handles structure

guidata(hObject, handles);
% UIWAIT makes Codigo_Huffman wait for user response (see UIRESUME)

% uiwait(handles.figure1);
% --- Outputs from this function are returned to the command line.
function varargout = Codigo_Huffman_OutputFcn(hObject, eventdata,
handles)
% varargout cell array for returning output args (see VARARGOUT);
% hObject handle to figure
% Get default command line output from handles structure

varargout{1} = handles.output;
function edit1_Callback(hObject, eventdata, handles)

% hObject handle to edit1 (see GCBO)
% Hints: get(hObject,'String') returns contents of edit1 as text

% str2double(get(hObject,'String')) returns contents of edit1
as a double
% --- Executes during object creation, after setting all properties.
%INICIO DEL PROGRAMA DEL DISEÑO DEL ARBOL Y PROGRAMACION DE LA

CODIFICACION DE HUFFMAN
47
clc;
axes(handles.axes1)
%% Ingreso de las palabras del usuario
word = get(handles.edit1,'String');%edita el nombre del cuadro de
edicion
%% 26. Lectura del archivo de Excel en Matlab y su respectivo

analisis de prob.
F = readtable('frecuencias.xlsx');%%leera los datos de nuestro archivo
excel
F.Signo(1) = {' '};
F.Signo = char(F.Signo);
F.Prob = F.Frecuencia / sum(F.Frecuencia);
letters = split(word,"");
letters( letters == "" ) = [];
[uniqueLetters,~,ix]= unique(letters);
letters=letters';
[ Lia, Locb ] = ismember(F.Signo,uniqueLetters);

uniqueLetters=char(uniqueLetters');
prob = F.Prob( Lia );%muestra las prob de mayor a menor
%
prob=(1:30);%es importante ya que define el tamaño de nuestra
prob.//si no se define generaremos errores en las matrices
%
prob = prob( Locb(Lia) );%ordena las letras alfabeticamente
prob=accumarray(ix,1);%acumulacion de array en prob.
prob=prob'; %invierte la matrix de columna a fila
rep = accumarray(ix,1);
rep=rep';
prob = prob.* rep;
%% INICIO DEL ANALISIS DE LA CODIFICACION DE HUFFMAN

for i=1:length(word)
%display(prob);
end
num_bits = ceil(log2(length(prob))); %Se calcula el número de bits
disp(' Probabilidad de caracteres:');
for i = 1:length(prob)
display(strcat(uniqueLetters(i),' --> ',num2str(prob(i))));
end
total = sum(prob);
disp('Total de la probabilidad')
disp(total);
%% Inicio de la matriz de codificacion
for i = 1:length(uniqueLetters)
clase_str {i} = uniqueLetters(i);
end
%mostramos la suma de la probabilidad
init_str = clase_str;
init_prob = prob;
%% Proceso de codificacion de Huffman
sorted_prob = prob;
rear = 1;
while (length(sorted_prob) > 1)
% Clase Probabilidad
[sorted_prob,indeces] = sort(sorted_prob,'ascend');
% Clase de la cadena basada en la incidencia
clase_str = clase_str(indeces);
48
% Crea nuevo simbolo
new_node = strcat(clase_str(2),clase_str(1));
new_prob = sum(sorted_prob(1:2));
% Se recorre el simbolo usado del viejo
clase_str = clase_str(3:length(clase_str));
sorted_prob = sorted_prob(3:length(sorted_prob));
% Agregamos un nuevo simbolo detras del viejo
clase_str = [clase_str, new_node];
sorted_prob = [sorted_prob, new_prob];
% Agregamos un nuevo simbolo
newq_str(rear) = new_node;
newq_prob(rear) = new_prob;
rear = rear + 1;
end
%% Formulario de datos del arbol de Huffman
tree = [newq_str,init_str];
tree_prob = [newq_prob, init_prob];
% Usamos la clase de elementos de arbol completo
[sorted_tree_prob,indeces] = sort(tree_prob,'descend');
sorted_tree = tree(indeces);
%% Calculos de los parametros del arbol
parent(1) = 0;
num_children = 2;
for i = 2:length(sorted_tree)
me = sorted_tree{i};% Extraemos el simbolo
% Buscamos un parecido de simbolo
count = 1;%el cout busca simbolos parecidos en las frecuencias
parent_maybe = sorted_tree{i-count};
diff = strfind(parent_maybe,me);
while (isempty(diff))
count = count + 1;
parent_maybe = sorted_tree{i-count};
diff = strfind(parent_maybe,me);
end
parent(i) = i - count;
end
%% Traza el arbol de Huffman
treeplot(parent);
title(strcat('Arbol de Codigo de Huffman - "',word,'"'));
%% Simbolos del arbol y sus probabilidades
display(sorted_tree);
display(sorted_tree_prob)
%% Extraccion de parametros del arbol
[xs,ys,h,s] = treelayout(parent);
text(xs,ys,sorted_tree);
% etiquetado de los bordes del arbol
% Uso las coordenadas para acomodarlo
my_x = xs(i);
my_y = ys(i);
% Uso el parentesco de las coordenadas
parent_x = xs(parent(i));
parent_y = ys(parent(i));
% Calculo el ancho de las coordenadas (midpoint)
mid_x = (my_x + parent_x)/2;
mid_y = (my_y + parent_y)/2;
%Calculo el ancho (Positiva = 1, Negativa = 0)
slope = (parent_y - my_y)/(parent_x - my_x);
if (slope > 0)
weight(i) = 1;
else
49
weight(i) = 0;
end
text(mid_x,mid_y,num2str(weight(i)));
end
%% Calculo del libro de Huffman
% Codigo de inicializar
code{i} = '';
% Crear un ciclo para encontra el parentesco
index = i;
p = parent(index);
while(p ~= 0)
w = num2str(weight(index));
code{i} = strcat(w,code{i});
index = parent(index);
p = parent(index);
end
end
% Salida de la consola-Libro de codigos de Huffman
codeBook=[sorted_tree', code']
axis on
axes(handles.axes3);
set(handles.axes3, 'visible', 'off')
cla
%para graficar los codigos de huffman
P = strcat(char(sorted_tree),'= ',char(code));
text('Interpreter','latex',...
'String',P,...
'Position',[0.3 .6],...
'FontSize',14);
function edit1_CreateFcn(hObject, eventdata, handles)

% hObject handle to edit1 (see GCBO)
% handles empty - handles not created until after all CreateFcns
called
% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
% --- Executes on button press in calcular.

function calcular_Callback(hObject, eventdata, handles)
% hObject handle to calcular (see GCBO)
% Define the character string

function axes1_CreateFcn(hObject, eventdata, handles)
% hObject handle to axes1 (see GCBO)
50
called
% Hint: place code in OpeningFcn to populate axes1
% --- Executes when entered data in editable cell(s) in uitable1.

function uitable1_CellEditCallback(hObject, eventdata, handles)
% hObject handle to uitable1 (see GCBO)
% eventdata structure with the following fields (see
MATLAB.UI.CONTROL.TABLE)
% Indices: row and column indices of the cell(s) edited
% PreviousData: previous data for the cell(s) edited
% EditData: string(s) entered by the user
% NewData: EditData or its converted form set on the Data property.
Empty if Data was not changed
% Error: error string when failed to convert EditData to appropriate
value for Data

function uitable1_CreateFcn(hObject, eventdata, handles)
% hObject handle to uitable1 (see GCBO)
called
% --------------------------------------------------------------------
function Untitled_1_Callback(hObject, eventdata, handles)
% hObject handle to Untitled_1 (see GCBO)
% --------------------------------------------------------------------
function Codificacion_Callback(hObject, eventdata, handles)
% hObject handle to Codificacion (see GCBO)
winopen('codificacion.pdf');%para llamar el archivo pdf que ingresamos
en la misma carpeta
% --------------------------------------------------------------------
function arbol_Callback(hObject, eventdata, handles)
% hObject handle to arbol (see GCBO)
winopen('arbol.pdf');
% --- Executes on button press in pushbutton2.

function pushbutton2_Callback(hObject, eventdata, handles)
% hObject handle to pushbutton2 (see GCBO)
set(handles.edit1,'string','')
51
called
% Hint: place code in OpeningFcn to populate axes2

called
52

Trabajo de Lapo

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Trabajo de Lapo

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD NACIONAL DE LOJA

Área De Energía, Las Industrias y Recursos Naturaleza No

CODIFICACION DE HUFFMAN EN MATLAB.

CICLO: CUARTO TELECOMUNICACIONES

Tomando como referencia la historia de la codificación de códigos o sobre su

El planteamiento de este proyecto fue de describir el diseño del árbol y la

Crear un programa que permita al usuario interaccionar con la codificación

3.2. OBJETIVOS ESPECIFICOS

Implementar los conocimientos sobre codificación de Huffman dentro del

Se investigo acerca de cómo trabajar con la interfaz Guide de Matlab, su

Tener conocimientos y bases acerca de programación ya previsualizadas

Con la información ya investigada se decidió realizar el prediseño del interfaz ya

Se procedió a la construcción del interfaz trabajando con Guide, esto basándose

Ya teniendo nuestro interfaz establecido, se comienza a trabajar con la lógica del

Igualmente, con mucha ayuda del material propuesto en internet específicamente

Este mismo combina un entorno de escritorio perfeccionado para el análisis

Ilustración 3. Pantalla de GUIDE y sus respectivas herramientas.

5.4 PUSH BUTTON

En el GUIDE de la ilustración del botón “push Button” es el que aparecerá.

Ilustración 5. Del cuadro de texto editable en Guide.

5.6 STATIC TEXT

Ilustración 7. Herramienta de Guide para graficar.

Abierta la interfaz se puede proceder a la programación de cada herramienta que

Puede guardar su función:

 En un archivo de función que solo contenga definiciones de función. El

readtable determina el formato de archivo a partir de la extensión del archivo:

 .txt, .dat, or .csv para archivos de texto delimitados.

5.11 SPLIT (STR, DELIMETER)

 Si A es una tabla o un calendario, unique devuelve las filas únicas de A

5.13 [Lia, Locb] = ismember (__)

Para una matriz m-por-n, cada fila representa un subíndice n-dimensional en la

initVal: endVal: incrementa la variable index de initVal a endVal en 1 y repite la

valArray: crea un vector de columna, index, a partir de las columnas posteriores

5.19 CODIFICACION DE HUFFMAN

La codificación de Huffman es un algoritmo esencial en la compresión de datos,

También es utilizada en numerosas ocasiones para comprimir cadenas de bits

5.20 ARBOL DE HUFFMAN

Ilustración 9. Árbol de Huffman.

También analizando sobre libros de criptografía cifrada y sus tablas de

Tomando todos estos análisis se llegó a la conclusión de que la tabla de la “La

Ilustración 10. Manual del Programador Anexo 1.

1. Ventana de inicio del programa de Matlab

7. En command window se escribira guide para iniciar el diseño de la

Ilustración 12. Manual del Programador Anexo 3.

8. Blank GUI(Default): se selecionara para iniciar con la creación de Guide.

Ilustración 13. Manual del Programador Anexo 4

Ilustración 15. Manual del Programador Anexo 6.

Ilustración 16. Manual del Programador Anexo 7.

Ilustración 17. Manual del Programador Anexo 8.

Ilustración 18. Manual del Programador Anexo 9.

25. Ingreso de las palabras del usuario

Ilustración 20. Manual del Programador Anexo 11.

Ilustración 21. Manual del Programador Anexo 12.

Ilustración 22. Manual del Programador Anexo 13.

Ilustración 23. Manual del Programador Anexo 14.

Ilustración 24. Manual del Programador Anexo 15.

Ilustración 25. Manual del Programador Anexo 16.

Ilustración 26. Manual del Programador Anexo 17.

1. Ventana de ejecución del programa.

Ilustración 27. Manual del Usuario Anexo 18.

Ilustración 27. Manual del Usuario Anexo 18.

Ilustración 28. Manual del Usuario Anexo 19.

Ilustración 29. Manual del Usuario Anexo 20.