Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Memoria PDF
Memoria PDF
Facultad de Informtica.
Universidad Complutense de Madrid.
Curso 2008-2009
Junio 2009
INDICE
1. Resumen ...................................................................................................................... 1
1.1 TALFi (Versin en castellano) ............................................................................ 1
1.2 TALFi (English version) ...................................................................................... 1
2. Objetivos ...................................................................................................................... 3
3. Informacin ................................................................................................................. 5
3.1 Antecedentes ......................................................................................................... 5
3.2 Introduccin terica a la aplicacin .................................................................... 5
3.3 Viabilidad .............................................................................................................. 8
3.4 Ejercicios posibles ................................................................................................. 8
3.4.1 Ejercicios automticos ................................................................................... 8
3.4.2 Ejercicios no automticos ........................................................................... 33
3.5 Requisitos tecnolgicos ....................................................................................... 33
3.6 Entorno de desarrollo......................................................................................... 33
3.7 Bibliotecas usadas ............................................................................................... 33
3.8 Arquitectura de la aplicacin ............................................................................ 34
3.9 Pruebas del Sistema ............................................................................................ 34
3.10 Implementacin y cierre del proyecto ............................................................ 34
3.11 Posible trabajo futuro ...................................................................................... 35
4. Descripcin de la aplicacin .................................................................................... 39
4.1. Patrones de diseo ............................................................................................. 39
4.2 Visin terica de la Aplicacin .......................................................................... 40
4.3. Diagramas UML ................................................................................................ 45
4.5 Suposiciones y dependencias ............................................................................. 53
4.6 Bases de datos ..................................................................................................... 54
4.6.1 Base de datos de usuarios............................................................................ 54
4.6.2 Base de datos de ejemplos y ejercicios ....................................................... 55
5. Manual de usuario .................................................................................................... 57
5.1 Perfiles de usuario .............................................................................................. 57
5.2 Ejecucin de algoritmos ..................................................................................... 57
5.3 Sistema de proposicin y evaluacin de ejercicios ........................................... 61
5.4 Cambiar propiedades de los estados y aristas.................................................. 63
5.5 Copiar, cortar y pegar ........................................................................................ 65
5.6 Seleccionar parte de un autmata. Interaccin ............................................... 66
5.7 Almacenar y recuperar autmatas y ejercicios. Adjuntarlos a la BD ........... 68
5.7.1 Guardar/Recuperar autmatas dibujados ................................................ 68
5.7.2 Recuperar ejercicios .................................................................................... 71
5.8 Aclaraciones finales ............................................................................................ 72
6. Planificacin temporal del proyecto ....................................................................... 73
6.1. Diagrama de Gantt ............................................................................................ 73
6.2. Resumen de la planificacin temporal ............................................................. 73
7. Glosario de trminos ................................................................................................ 75
8. Palabras clave ........................................................................................................... 77
9. Conclusin ................................................................................................................. 79
10. Bibliografa .............................................................................................................. 81
Anexos ............................................................................................................................ 83
Anexo 1. Listado de rdenes de la aplicacin por consola .................................... 85
Anexo 2. WEB Applet de la aplicacin ................................................................... 87
Anexo 3. JavaDoc...................................................................................................... 89
Anexo 4. Estructura archivos XML ........................................................................ 91
TALFi 1
Captulo 1.
Resumen
Captulo 2.
Objetivos
El objetivo principal de la aplicacin es ser una herramienta til de estudio para los
estudiantes de asignaturas que traten sobre autmatas y las diferentes interacciones entre
ellos. Como el motivo docente es evidente, hemos implementado una herramienta
visual, donde el usuario puede interaccionar en una interfaz grfica, en donde se
muestra todo el potencial de la aplicacin.
Otro de los objetivos es que los alumnos, o usuarios, puedan con TALFi resolver
ejercicios de autmatas de manera automtica y servirse de dicha herramienta para
averiguar la correccin o incorreccin de sus soluciones. Por tanto, la solucin que les
mostrar nuestra herramienta se podr utilizar tanto para averiguar cmo se realiza un
ejercicio, como para comprobar la solucin propia averiguando en que paso se ha
cometido un error o si sta es correcta.
Para poder cumplir estos objetivos creemos conveniente que la aplicacin implemente
todos los algoritmos automticos de la parte de lenguajes regulares. Es decir, cualquier
transformacin entre los distintos de autmatas finitos y las expresiones regulares. Por
lo tanto, nuestra aplicacin permitir generar un ciclo, pasando por todos los autmatas
y expresiones regulares. Esta transformacin se realizar siguiendo el siguiente
esquema:
Tambin nos parece interesante que nuestra aplicacin permita minimizar los AFD. De
esta forma se podr comprobar la equivalencia entre iguales. Esta equivalencia se
lograr a travs de la transformacin de cualquiera de ellos en el correspondiente AFD
mnimo y se comprobar la igualdad entre los autmatas finitos deterministas
correspondientes.
La codificacin de la aplicacin se enfocara en dos partes diferenciadas: una que
corresponde con la lgica de los algoritmos y de la aplicacin en general y otra que
corresponder con la parte de interaccin con el usuario y muestra de resultados. En una
primera etapa bajo una vista por consola y a posteriori con una interfaz grfica de
usuario amigable y de fcil manejo.
La consola utilizar el enfoque UNIX ya que es un estndar muy usado en la actualidad
y conocido por todo el mundo. La aplicacin grfica generar rdenes de consola
automticamente en funcin de la seleccin del usuario. De esta manera ser posible
realizar mejoras en la codificacin de la interfaz sin tener que modificar la lgica de la
aplicacin, ya sea creando diferentes interfaces grficas sobre la misma consola o
modificando la existente.
Hay que tener en cuenta que pretendemos que la aplicacin sea fcilmente mejorada y
ampliada con nuevos autmatas, mquinas de Turing y otros conocimientos que se
estudian en Teora de Autmatas que no se han tenido en esta. Por tanto,
implementaremos el cdigo de los algoritmos e interfaz grfica con vistas a posibles
mejoras y ampliaciones futuras. Adems dicho cdigo deber estar documentado con el
4 TALFi
Captulo 3.
Informacin
3.1 Antecedentes
No conocemos ningn antecedente directo o indirecto de una aplicacin que trate el
tema de los autmatas con la intencin docente que le hemos dado nosotros.
Precisamente por ello elegimos ste proyecto, ya que nos gustaba la idea de crear algo
que ayudara a los alumnos en su estudio de autmatas.
Si bien no existe ninguna herramienta con marcado carcter docente de este tipo, si que
existe una llamada JFLAP de la que nuestro proyecto toma ciertas ideas intuitivas a la
hora del diseo de la interfaz grfica, ya que en s la que plantea dicha herramienta nos
parece sencilla en cuanto a su manejo. Sin embargo hemos aadido mucha
funcionalidad a la parte grfica y desarrollado los algoritmos desde cero con la
intencin docente de que los alumnos puedan visualizar los pasos al aplicar cualquier
algoritmo, opcin no disponible en JFLAP.
Todos estos tipos de autmatas (AFD, AFND y AFND-) aceptan los mismos
lenguajes, es decir, los lenguajes regulares. Por lo tanto, siempre se puede construir un
AFD que acepte el mismo lenguaje que el dado por un AFND o que un AFND- y al
revs.
Expresin regular sobre un alfabeto (ER)
Una expresin regular describe un conjunto de cadenas sin enumerar sus elementos.
Toda expresin regular bsicamente se puede ver como una cadena formada por las
letras del alfabeto y ciertos operadores. Para que la cadena sea considerada una
expresin regular deber seguir una construccin gramatical correcta.
A continuacin presentamos las reglas para la construccin de expresiones regulares de
manera recursiva:
1. , la palabra vaca, es una expresin regular. En nuestra aplicacin la palabra
vaca se representa con el smbolo
2. es una expresin regular tambin, que identifica el conjunto vaco de
palabras que se reconocen, es decir, ninguna.
3. Cualquier letra perteneciente al alfabeto es una expresin regular en s
misma.
Dadas las anteriores expresiones regulares, consideremos ahora que E y F son
expresiones regulares correctamente formadas entonces:
4. E + F (operacin de suma) es tambin una expresin regular.
5. EF o EF (operacin de concatenacin) es una expresin regular correcta. En
nuestra aplicacin optaremos por la segunda representacin.
8 TALFi
3.3 Viabilidad
La viabilidad del proyecto ha sido lo primero que hemos tenido que acotar, dado que
es una materia donde se puede entrar en muchos temas distintos. Como el objetivo de la
aplicacin es ser una herramienta docente, hemos querido centrarnos en uno de los
temas principales del estudio de autmatas: la interaccin entre los diferentes autmatas
finitos y el paso de una expresin regular a su equivalente autmata.
Una vez acotado nuestro proyecto, no hemos encontrado ningn punto terico que haya
sido insalvable.
Aqu podemos observar el autmata final obtenido tras la minimizacin. Donde se ven
las nuevas transiciones y los nuevos estados que lo conforman.
TALFi 11
((00+(1+01)(11+0(0+11))*(10+010))*)*+(00+(1+01)(11+0(0+11))*(10+010))*(1+01)(
11+0(0+11))*
En la aplicacin TALFI obtenemos el mismo resultado:
Obteniendo la salida por pasos del algoritmo en la aplicacin sobre el mismo autmata
finito, obtenemos:
14 TALFi
TALFi 15
El autmata obtenido no contiene todas las transiciones que tendra un autmata finito
determinista puro. Faltara incluir un estado basura, de no aceptacin, al que lleguen las
transiciones que faltan.
Hemos decidido no incluir dicho estado por simplicidad y facilidad de comprensin del
resultado devuelto.
5. Ejercicio de transformacin de AFND- a AFND
El algoritmo desarrollado para resolver este ejercicio consiste en lo siguiente:
Entrada: autmata finito no determinista con transiciones lambda.
Salida: autmata finito no determinista.
Se eliminan las transiciones lambda y para cada una de ellas se aaden todas las
transiciones que se encuentran en el cierre lambda del estado origen.
Dado el siguiente autmata con transiciones lambda:
20 TALFi
Salida:
stas son las imgenes que muestra la pgina HTML de pasos y que se corresponden
con la creacin del autmata segn se va recorriendo el rbol sintctico (ver imagen
superior) que se ha generado. Cada uno de los autmatas tiene como ttulo el nmero de
paso en que se genera y la operacin que lo desencadena (como aclaracin para el
usuario):
24 TALFi
TALFi 25
26 TALFi
TALFi 27
28 TALFi
TALFi 29
30 TALFi
TALFi 31
Y el autmata final, que es el del ltimo paso del algoritmo, unin de los anteriores
dependiendo de la operacin que sea:
32 TALFi
http://www.eclipse.org/
http://java.sun.com/javase/downloads/index.jsp
- Desarrollo de la interfaz:
La interfaz desarrollada en Java es sencilla de manejar y comprender para cualquier
usuario a la que va destinada la aplicacin, con mensajes de ayuda y aclaraciones para
posibles dudas a cerca del funcionamiento de algn componente especfico. Los
mtodos de entrada y salida de datos estn presentes tanto en forma interna (XML
internos dentro de la propia aplicacin), como externa mediante el uso de archivos
HTML.
Captulo 4.
Descripcin de la aplicacin
Tras sta introduccin de los aspectos externos de la aplicacin que hemos considerado
ms importantes, vamos a ver una descripcin ms exhaustiva de la aplicacin en s. La
aplicacin est dividida en dos partes: la aplicacin por consola y el interfaz grfico que
funciona sobre la aplicacin de consola.
La aplicacin por consola es plenamente funcional. Ha sido usada para hacer pruebas
internas y probar que los algoritmos implementados funcionan correctamente.
El interfaz grfico extiende las posibilidades de la aplicacin por consola. Ofrece un
entorno visual ms amigable e intuitivo. Creemos que introducir y mostrar los
resultados de una forma grfica es indispensable en una aplicacin de stas
caractersticas.
Iremos explicando ambas formas de entender la aplicacin a lo largo de ste apartado.
Para ello consideramos que la mejor forma es ir desgranndola desde la base, el inicio
del proyecto, a los apartados finales.
a) Modelo-Vista-Controlador:
La vista est formada por todas las clases relacionadas con la interfaz grfica.
El modelo est formado por todas las clases relacionadas con la lgica de la aplicacin,
es decir: algoritmos, autmatas, alfabetos, expresiones regulares.
El cometido del controlador es hacerles interactuar entre ambos, siempre que el
controlador lo permita.
Es decir, la vista nunca accede al modelo sin pasar por el controlador y viceversa
(ver diagramas de interaccin en las pginas 46 a 48).
b) Singleton:
40 TALFi
El patrn Singleton se aplica cuando nos interesa que un objeto sea nico en la
aplicacin, y que el acceso a ella sea por un nico sitio.
Nuestra aplicacin contiene varios objetos que exigen ese tratamiento:
Tenemos un nico traductor HTML.
Un nico mensajero.
Un nico controlador.
Un nico parser de xml.
Una nica clase par guardar el autmata copiado o cortado para pegarlo.
c) Application Service:
A. Autmatas
El paquete de autmatas incluye las siguientes clases e interfaces, que pasaremos a
explicar a continuacin una por una:
Alfabeto y Alfabeto_imp.
Automata.
AutomataFD.
AutomataFND.
AutomataFNDL
TALFi 41
Alfabeto y Alfabeto_Imp
Alfabeto es una interfaz que define las funciones de los alfabetos de la
aplicacin. Alfabeto_Imp implementa stas funciones. Estn incluidas las
funciones que consideramos bsicas como pueden ser devolver listas de letras,
devolver el alfabeto entero, ver si est una letra en el alfabeto etc.
Autmata
Interfaz que define las funcionalidades bsicas para cualquier autmata, sea del
tipo que sea.
AutomataFD
Clase que implementa todas las funciones de Autmata. Funciones que permiten
entre otras cosas mostrar las aristas de un vrtice en concreto, insertar aristas,
mostrar los estados que componen el autmata, eliminar vrtices etc.
AutomataFND y AutomataFNDLambda
Clases que extienden AutomataFD, ya que adems de las funciones definidas en
Autmata necesitan de otras funciones especficas para resolver otras cuestiones
propias del autmata en concreto. Funciones como cierre lambda, que calcula el
cierre lambda de un estado, o delta extendida que devuelve la lista de estados a
los que podemos ir usando una letra del alfabeto nos permiten tratar stos
autmatas correctamente.
Coordenadas
Clase que almacena las coordenadas de los estados. Se usa nicamente en la
parte grfica de la aplicacin en el caso de que se guardara el autmata
incluyendo las coordenadas que se generan tras la modificacin.
B. Expresin regular
El paquete de Expresin Regular contiene las siguientes clases e interfaces que
explicaremos a continuacin:
ArbolER y ArbolER_Imp.
ExpresionRegular y ExpresionRegular_Imp.
ArbolER y ArbolER_Imp
ArbolER es una interfaz que define la funcionalidad de los rboles sintcticos
para expresiones regulares. Incluye funciones bsicas para el tratamiento de
rboles binarios, como getHijoIz que devuelve el hijo izquierdo de un nodo,
getRaiz que devuelve la raz del rbol, o setHijoDr que modifica el hijo derecho
de un nodo. La clase que implementa a la interfaz es ArbolER_Imp.
ExpresionRegular y ExpresionRegular_Imp
ExpresionRegular es una interfaz que define los mtodos que debe implementar
las expresiones regulares. Funciones como getExpresionRegular, o getArbolER
son imprescindibles para el tratamiento de expresiones regulares. La clase que
implementa sta interfaz es ExpresionRegular_Imp.
42 TALFi
C. Algoritmos
El paquete de Algoritmos contiene las siguientes clases e interfaces que explicaremos a
continuacin:
Algoritmo.
ERtoAFNDLambda.
AFD_TO_ER.
Minimizacin.
Automatas_Equivalentes.
AFN_TO_AFD.
AFNDLambda_to_AFND.
Algoritmo
Interfaz que define todos los mtodos que debern tener como mnimo cada uno
de los algoritmos que se quieran crear en la aplicacin, es una interfaz sencilla,
con nicamente tres mtodos, a saber: ejecutar que recibe como parmetro si es
por pasos, registrarControlador que identifica el controlador que llevar acabo la
ejecucin, en caso de que haya ms de uno y finalmente el mtodo que devuelve
el xml getXML de pasos en caso de que se haya ejecutado con esa opcin.
ERtoAFNDLambda
Algoritmo que implementa la interfaz antes descrita y que aade a estos tres
mtodos varios privados que realizan en conjunto la implementacin del
algoritmo que obtiene el autmata finito no determinista con transiciones lambda
equivalente a la expresin regular que hace las veces de entrada al algoritmo.
Para ello simplemente se transforma a un rbol sintctico que se va recorriendo,
por cada nodo del rbol recorrido, se obtiene el autmata finito no determinista
con transiciones lambda equivalente hasta el momento. Por cada paso se genera
un comentario predefinido dependiendo de la operacin que se aplique que
posteriormente se aadir al HTML que se muestra, como aclaracin para los
alumnos.
AFD_TO_ER
Algoritmo que implementa la interfaz y define nuevos mtodos que ayudan en
su ejecucin. En este caso se enfoca el algoritmo mediante la eliminacin de
estados no finales, con la excepcin del inicial, modificando las transiciones
entre los que no se eliminan de forma que el autmata tras la eliminacin
reconozca el mismo lenguaje. Una vez termina este proceso para cada estado no
final se calcula su expresin regular, partiendo del estado inicial que como se ha
comentado se mantiene en el autmata, para posteriormente concatenando todas
las expresiones obtenidas para generar una nica expresin final resultado. Hay
varios factores que implican un cambio en el desarrollo del algoritmo, uno de
ellos y quiz el ms importante es el comprobar si el estado inicial del autmata
es tambin final, pues dependiendo de esto la expresin resultante deber tener
unas caractersticas u otras.
TALFi 43
Minimizacin
Algoritmo de minimizacin de autmatas finitos deterministas, cuenta con los
tres mtodos que debe implementar de la interfaz Algoritmo y con numerosos
mtodos privados debido a la complejidad del algoritmo. Los mtodos privados
llevan el verdadero cmputo que realiza y los mtodos implementados hacen la
labor de interfaz con el resto de la aplicacin.
Se genera un nuevo autmata basado en el de entrada, colapsando aquellos
estados que son indistinguibles.
Automatas_equivalentes
Algoritmo de equivalencia de autmatas, de nuevo cuenta con los tres mtodos
que debe implementar y otros privados y pblicos, los primeros son los que se
encargan de la implementacin propiamente dicha del algoritmo y los segundos
son los que llevan a cabo la inicializacin de los dos autmatas que intervienen
en el algoritmo y la preparacin previa del mismo.
Enfocamos el algoritmo de una manera prctica, inicializamos una nica tabla
que identifica a los autmatas con una mezcla de ambos (renombrando estados si
es necesario) y minimizamos a fin de encontrar distinguibilidad entre los estados
de los dos autmatas. La respuesta se calcula en funcin del resultado de esta
distinguibilidad obtenida en la tabla nica.
AFN_TO_AFD
Algoritmo de transformacin de autmata finito no determinista a autmata
finito determinista, como el resto de algoritmos cuenta con los tres mtodos que
debe implementar y otros privados.
El algoritmo genera un nuevo autmata a partir del no determinista, obteniendo
nuevos estados a partir de las aristas no deterministas.
AFNDLambda_to_AFND
Algoritmo que implementa la interfaz Algoritmo, extendindola con nuevos
mtodos propios para la ejecucin del mismo.
Dado un autmata con transiciones lambda, lo transformaremos en uno
equivalente sin ellas. Para ello nos guiaremos de una serie de pasos, que se
ejecutarn para cada estado del autmata, y para cada letra del alfabeto del
mismo. Los pasos son:
Cierre lambda del estado
Delta extendida de los estados del cierre lambda, usando todas las
letras del alfabeto.
Los estados cuya delta extendida lleven a un estado sern una arista
entre ste estado y el estado inicial del que se ha hecho el cierre
lambda.
Ejecutando stos pasos para todos los estados del autmata, tendremos como
resultado un autmata finito no determinista sin transiciones lambda.
44 TALFi
D. Controlador
El paquete de Algoritmos contiene las siguientes clases e interfaces que explicaremos a
continuacin:
Controlador.
Controlador_imp.
Controlador
Interfaz que define los mtodos necesarios que debern implementar las clases
que pretendan ejercer de controlador, en este caso el controlador dentro de la
aplicacin se encarga de recibir la query (ver apndice uno a final de la memoria
para ms informacin) que prepara la vista grfica segn los deseos del usuario y
pasar los parmetros correctos al algoritmo correspondiente que se selecciona
mediante las opciones especificadas en la query.
Los mtodos son: registrarVista, getSalida, obtenerXML, tratarMensaje y
setIdioma.
Controlador_imp
Esta es la clase que ejerce el papel de controlador en la aplicacin, como es
evidente, implementan todos los mtodos de la interfaz anterior y algunos ms
que son de rgimen privado y que realizan varias labores necesarias en la
aplicacin.
Es labor del controlador obtener los archivos xml de pasos, para delegando en
otras clases, convertirlos a un formato html, del cual se pasar la ruta a la vista
para que lo muestre. Tambin deber obtener del algoritmo correspondiente el
resultado, ya sea un autmata o una expresin regular, que de nuevo mandar a
la vista para que se encargue de mostrarla.
As mismo, tambin tiene la capacidad, delegando en otras clases, de extraer
tanto autmatas como expresiones regulares de archivos xml, para obtener la
entrada que el usuario haya introducido grficamente.
Una vez descritos los paquetes de cdigo ms importantes de la aplicacin, pasaremos a
explicar el comportamiento de las clases y su interaccin a la hora de la ejecucin de las
diferentes opciones que tiene la aplicacin TALFi con la ayuda de los diagramas UML.
TALFi 45
Consultar/Corregir ejercicios
Minimizar autmatas
deterministas
Equivalencia de dos
autmatas
Obtener autmata de
expresin regular
Transformar autmata
indeterminista a determinista
46 TALFi
1: getInstancia()
2: Controlador_imp
3: ejecuta()
4: getPanel()
5: AutomataCanvas
6: traducirXML()
7: String automata
8: new File
9: append(String Automata)
10: getInstancia()
11: TraductorHTML
12: getInstancia()
13: ParserXML
14: extraerAutomata(File)
15: Automata
16: generarJPG(imagen,Automata)
17: ejecuta()
18: getPanel()
19: AutomataCanvas
20: traducirXML()
21: String
23: append(String)
String query
= TALF -e (pasos) ruta file1
ruta file2
26: obtenerAutomata()
27: getInstancia()
28: ParserXML
30: Automata a
31: obtenerAutomata2()
32: getInstancia()
33: ParserXML
35: Automata b
38: registraAutomata1(Automata a)
39: registraAutomata2(Automata b)
40: generaAutomataConjunto()
43: Controlador_imp
45: registraControlador(Controlador_imp)
46: setSolucionEquivalencia()
48: getTablaMinimizacion()
si pasos= true
se genera xml de pasos 50: existenLasParejas(automata)
51: getXML()
55: getInstancia()
56: TraductorHTML
57: salidaXML()
Diagrama de interaccin para el algoritmo de paso de expresin regular a autmata no determinista con
lambdas.
TALFi 51
OyenteM enuI Panel Al fabet Alfabeto_i m Panel Expres VistaGrafica T raductorHT Fil e ParserXML ER_T O_AF ExpresionRe Arbol_im p Panel Central AutomataCa
Controlador_
tem o p ionRegul ar ML NDLambda gular_i mp nvas
im p
1: new PanelAlfabeto()
2: new Al fabeto_imp()
4: getAl fabeto()
5: Al fabeto
Se introduce la
expresi n regular
7: getExpresionRegul ar()
8: Stri ng expresion
9: traducirXML()
14: getInstancia()
15: Controlador_im p
19: ParserXML
String ruta=query[2]
26: ExpresionRegular a
boolean pasos=query[pasos]
32: registraControlador(Controlador)
37: String Xm l
40: salidaXML()
42: getInstancia()
43: TraductorHTML
51: cargarAutomataNuevo(Automata a)
1: ejecutar(boolena pasos)
2: new File(String ruta)
3: getPanel()
4: AutomataCanvas
5: traducirXML()
6: String texto
7: append(texto)
8: generarImagenJPG(String rutaImg)
9: getInstancia()
10: Controlador_imp
13: ParserXML
String ruta=query[2]
15: Automata a
boolean pasos=query[pasos]
24: append(xml)
25: salidaXML()
27: getInstancia()
28: TraductorHT ML
29: traducirPasosAFDT OER(rutaXML)
31: getSalida()
33: setExpresion(salida)
Captulo 5.
Manual de usuario
Para dibujar un nuevo autmata, del tipo que sea, en la interfaz grfica debemos hacer
click sobre el siguiente botn:
La flecha indica que ests activando el modo de editar, es decir puedes seleccionar los
estados y aristas y moverlos por la ventana.
El crculo es el smbolo de Nuevo Estado, al pulsarlo, el sistema nos solicita el nombre
y su condicin de final, inicial o estado normal.
58 TALFi
La barra es el smbolo de nueva arista, una vez pulsado, debemos seleccionar un estado
y llevar la arista que se dibuja a otro estado, o al propio estado.
El sistema nos solicita cual es el smbolo (letra del alfabeto), encargado de hacer la
transicin.
La calavera permite eliminar estados y aristas, una vez que se ha pulsado, haciendo
click con el ratn sobre un estado o una arista, desaparecer.
En cualquier momento podemos editar un estado o una arista, debemos pulsar con el
botn derecho del ratn sobre un estado o una arista y el sistema nos permitir
modificar sus caractersticas.
Hay que tener en cuenta que en los autmatas con transiciones lambda el smbolo / es la
lambda, si usamos ese smbolo al etiquetar una transicin mientras dibujamos un
autmata, dicho autmata se considerar autmata con transiciones lambda.
Para cargar una expresin regular en el sistema debemos utilizar el siguiente botn:
Si elegimos la primera opcin, se abrir una pgina web html, con toda la informacin
de ejecucin del algoritmo y se cargar el autmata con transiciones lambda en la
ventana principal.
Si por el contrario decidimos ejecutarlo sin pasos, el sistema cargar el autmata con
transiciones lambda en la ventana principal, sin mostrar la pgina HTML con los pasos.
Los ejemplos se dividen en los tres tipos de autmatas con los que trabaja la aplicacin,
si como en la imagen seleccionamos el ejemplo 4, se est seleccionando un autmata
finito determinista, esto hay que tenerlo en cuenta para posteriormente seleccionar el
algoritmo adecuado.
En este caso, los algoritmos posibles seran: minimizacin, equivalencia de autmatas y
traduccin de autmata finito determinista a expresin regular.
Una vez cargado el ejemplo, podremos modificarlo a nuestro gusto, con los botones de
edicin, al igual que ocurre con los autmatas dibujados por nosotros.
Haciendo doble click con el ratn sobre cualquiera de los ejemplos, cargaremos la
informacin del ejemplo sobre la ventana principal, como se ve en la siguiente imagen.
60 TALFi
Si decidimos ver los pasos, el sistema ejecutar un explorador de internet y cargar una
pgina web html con la informacin de ejecucin y los pasos de ejecucin.
En el ejemplo mostrar: el autmata de entrada, la tabla de minimizacin y el autmata
de salida.
Adems el sistema cargar en la interfaz grfica el nuevo autmata generado, en nuestro
ejemplo, el autmata minimizado, con el cual podemos operar y aplicar nuevos
algoritmos.
Otros algoritmos tienen un tratamiento distinto, pero es sencillo seguir las instrucciones
que marca la aplicacin para ejecutarlos.
Una vez terminado el dibujo, debemos enviarlo a corregir, pulsando sobre el botn
Mandar solucin. El sistema nos indicar cual es el resultado de la correccin, como se
ve en la siguiente imagen:
De igual forma se procede con las aristas, solo que en este caso la ventana de cambio de
propiedades es distinta e incluye un campo de texto (relleno con las letras de la
transicin) para poner las letras que desencadenarn el paso por la arista y que se
pueden modificar o aadir nuevas y dos mens donde estn los estados entre los que
est dibujada la arista y que podemos cambiar a nuestro gusto sin ms que seleccionar
los estados entre los que deseemos que se redibuje la arista de cualquiera de las dos
listas con todos los estados del autmata. De nuevo al aceptar los cambios son visibles
de forma inmediata.
En la imagen a continuacin expuesta se ve que hemos pinchado con el derecho sobre la
arista que une los estados Q1 y Q2 y que tiene como letra una b, la siguiente imagen
muestra el cuadro de texto explicado del cambio de propiedades de las aristas.
TALFi 65
Como podemos ver en las imgenes los botones de pegar estn desactivados, por qu?
Es que no se puede pegar? Pues no, hasta que no hayamos copado o cortado alguna vez
no es posible pegar nada, una vez hayamos hecho cualquiera de las dos cosas el botn
de pegar se activar y ya podremos pegar todas las veces que deseemos, siempre se
pegar el ltimo autmata cortado.
Los eventos de copiar, cortar y pegar en la aplicacin realizan la accin sobre el
contenido completo del panel, es decir que copian, cortan y pegan autmatas completos,
en ningn caso se puede seleccionar parte de un autmata y copiarlo, cortarlo o pegarlo,
cosa que s se puede hacer a la hora de suprimir parte de un autmata como veremos
ahora.
Una vez seleccionada la parte deseada, podemos o bien variar su posicin dentro del
panel, o suprimir los estados seleccionados, para realizar esta ltima tarea slo hemos
de pulsar el botn suprimir y se eliminarn los estados que estn seleccionados y con
sus respectivas aristas tanto de entrada como de salida a los mismos.
En esta imagen hemos borrado los estados que seleccionamos anteriormente, nada ms
que pulsando suprimir.
Al pulsar sobre l, nos aparece una ventana de apertura de archivos muy similar a la de
guardar, donde debemos de buscar la carpeta que contenga el archivo que queremos
abrir. En el panel central de la vista de abrir, nos aparecern los archivos que contiene la
carpeta en la que estemos, sin embargo nica y exclusivamente aparecern las carpeta,
que podemos abrir para entrar en un nuevo directorio, y los archivos con extensin .xml
ya que son los nicos reconocidos por la aplicacin. Nada ms hemos de selecciona un
archivo vlido de un autmata y hacer doble click sobre l, o pulsar aceptar para que se
dibuje en el panel, manteniendo las coordenadas que los estados tenan cuando se
guard.
TALFi 71
Al pulsar sobre el botn aparece una ventana de dilogo igual a la que se utiliz para
abrir autmatas, y con las mismas caractersticas que aquella, con lo que remitimos al
lector a su explicacin para comprender esta.
Antes de concluir este apartado de guardar y recuperar autmatas y ejercicios, queremos
indicar otra optimizacin de la aplicacin, pues una vez se ha guardado o abierto un
autmata o ejercicio la siguiente vez que se intente realizar una de dichas acciones, la
aplicacin abrir la ventana de guardar o abrir respectivamente, con la ltima carpeta
72 TALFi
donde se guard o abri el ltimo archivo, es decir que la aplicacin guarda informacin
sobre la ltima carpeta en la que se efectu una accin de este tipo.
Captulo 6.
Trabajo
Especificacin Diseo
5% 5% Reuniones
Documentacin 5%
20%
Implementacin
30%
Correccin de errores
35%
Captulo 7.
Glosario de trminos
- Autmata:
Un autmata es un modelo matemtico para una mquina de estado finita (FSM sus
siglas en ingls). Una FSM es una mquina que, dada una entrada de smbolos, "salta" a
travs de una serie de estados de acuerdo a una funcin de transicin (que puede ser
expresada como una tabla). En la variedad comn "Mealy" de FSMs, esta funcin de
transicin dice al autmata a que estado cambiar dados uno determinado estado y
smbolo.
TALF:
Siglas de Teora de autmatas y lenguajes formales, asignatura del segundo curso de
Ingeniera Informtica en la universidad complutense de Madrid. Trata lo referente al
estudio de autmatas.
Alfabeto:
El alfabeto, es el conjunto ordenado de las letras de un idioma. Referente a los
autmatas, el alfabeto es el conjunto de letras que el autmata es capaz de comprender.
Lenguaje:
Un lenguaje formal es un conjunto de palabras (cadenas de caracteres) de longitud finita
en los casos ms simples o expresiones vlidas (formuladas por palabras) formadas a
partir de un alfabeto (conjunto de caracteres) finito. El nombre lenguaje se justifica
porque las estructuras que con este se forman tienen reglas de buena formacin
(gramtica) e interpretacin semntica (significado) en una forma muy similar a los
lenguajes hablados o naturales.
Expresin regular:
Una expresin regular es una expresin que describe un conjunto de cadenas sin
enumerar sus elementos. Los elementos estarn formados por smbolos del alfabeto que
describa la expresin regular.
Lambda:
Lambda ( ) es la u ncima
d letra del alfabeto griego. En el estudio de autmatas
normalmente se usa para nombrar a la palabra vaca.
Algoritmo:
Un algoritmo es una lista bien definida, ordenada y finita de operaciones que permite
hallar la solucin a un problema. Dado un estado inicial y una entrada, a travs de pasos
sucesivos y bien definidos se llega a un estado final, obteniendo una solucin.
Computabilidad:
La Teora de la computabilidad es la parte de la computacin que estudia los problemas
de decisin que pueden ser resueltos con un algoritmo o equivalentemente con una
mquina de Turing.
TALFi 77
Captulo 8.
Palabras clave
Autmata, TALF, alfabeto, lenguaje, expresin regular, lambda, algoritmo,
computabilidad.
TALFi 79
Captulo 9.
Conclusin
Desarrollar ste proyecto ha sido un autntico reto desde el principio hasta el final. Ya
que los algoritmos no solo deban funcionar y dar el resultado correcto sino que adems
deban aportar una explicacin de cmo se ha llegado al resultado final, mediante unas
tablas con los pasos que se han seguido para llegar a la solucin. Pasos que pueden
servir a los alumnos como gua y les ayudan a comprender la asignatura en su totalidad.
La lgica de la aplicacin se centra en la codificacin de todos los algoritmos
automticos de la parte terica de la asignatura relacionada con expresiones regulares y
autmatas finitos, cada uno de ellos con una salida explicativa en forma de los pasos
que se han de dar para obtener el resultado correcto.
La aplicacin permite convertir entre los diferentes tipos de autmatas y expresiones
regulares a otro cualquiera de estas materias, ya que se cierra el ciclo completo de
transformacin con todos los algoritmos desarrollados. Este era nuestro principal
objetivo, la realizacin de una aplicacin de autmatas y expresiones cerrada, de ayuda
a los alumnos.
Una vez que se cumple el objetivo de desarrollar una herramienta didctica a travs de
los algoritmos con la muestra de los pasos, hemos desarrollado una interfaz grfica
sobre la aplicacin por consola y la propia lgica de los algoritmos, funcionando de
manera independiente. La interfaz grfica aporta facilidad de uso y funcionalidad a los
usuarios que prefieran este enfoque ms visual.
Es posible utilizar la aplicacin si necesidad de la interfaz grfica gracias a la vista por
consola con comandos, muy al estilo de UNIX, y gracias a la creacin y edicin de
archivos XML con un formato determinado (ver apndice cuatro) que representan los
parmetros de entrada a los algoritmos.
La interfaz grfica es traducible a cualquier idioma pensando en posibles usos para
alumnos de cualquier nacionalidad. La versin entregada puede ser utilizada en ingls y
espaol. Se puede traducir de manera sencilla a cualquier otro idioma ya que cuenta con
ficheros XML de lenguajes.
En la interfaz grfica se incluye la capacidad de creacin de ejercicios por parte del
profesor. Estos ejercicios pueden ser enviados a los alumnos para que los intenten
realizar en sus ordenadores y comprueben el resultado con el que ha introducido el
profesor como solucin en el propio ejercicio, es decir, una vez el profesor los ha
enviado el ejercicio ste se corrige automticamente si la necesidad del reenvo de la
solucin. De esta forma el alumno puede autoevaluarse y aprender de sus errores.
Los resultados de los ejercicios bien o mal realizados se guardan en la base de datos del
usuario de forma que el profesor puede controlar si se han dado las respuestas
correctamente o no y en cules de ellos.
En la aplicacin hemos reunido muchos conocimientos aprendidos durante la carrera en
multitud de asignaturas que hemos estudiado, en nuestro caso, las pertenecientes a la
rama de software, que son:
Captulo 10.
Bibliografa
Nuestro director de proyecto es profesor en la temtica que trata el proyecto, y la mayor
fuente de informacin procede de las reuniones con l y sus propias notas.
A pesar de ello hemos tenido que consultar alguna bibliografa complementaria para
implementar alguno de los algoritmos, de la que dejamos aqu constancia:
1- Hopcraft, Motwani, Uliman.
"Introduccin a la teora de autmatas. Lenguajes y computacin"
Addison Wesley 2002.
2- Dean Kelley:
"Teora de Autmatas y Lenguajes Formales".
Prentice Hall, 1997.
3- J. G. Brookshear,
Teora de la Computacin: Lenguajes Formales, Autmatas y Complejidad,
Addison-Wesley Iberoamericana, 1993.
TALFi 83
Anexos
TALFi 85
Anexo 1.
Anexo 2.
Anexo 3.
JavaDoc
Todo el cdigo fuente de la aplicacin cuenta con comentarios explicativos, aparte de
ello hemos realizado toda la documentacin JavaDoc que permitir a futuros
desarrolladores reutilizar el cdigo y comprenderlo mejor, ya que adjuntamos con l
toda una API de funcionalidad sobre cada una de las clases, mtodos y funciones que
contiene el cdigo fuente.
ndice del JavaDoc de la aplicacin: se encuentra en el CD adjunto a la memoria en la
carpeta JavaDoc. El ndice se encuentra en la pgina: index.html.
TALFi 91
Anexo 4.
</mensajes>
</arrow>
<arrow>
<state>S0</state>
<state>S0</state>
<item>0</item>
</arrow>
<arrow>
<state>S1</state>
<state>S1</state>
<item>1</item>
</arrow>
</arrows>
</authomata>
5.-Archivos XML relacionados con los ejercicios
Estos archivos almacenados en la carpeta de ejercicios, aunque pudieran aparecer en
cualquier otro lugar, se pueden generan automticamente mediante la interfaz grfica y
contiene toda la informacin relacionada con los ejercicios a resolver por los usuarios,
es decir, enunciado, entrada y resultado.
Como por ejemplo, el siguiente ejemplo de minimizacin de autmatas:
<ejercicio>
<tipo>Minimizacion</tipo>
<enunciado>Minimiza el siguiente automata finito</enunciado>
<input>
<authomata>
<type>
<item>AutomataFD</item>
</type>
<alphabet>
<item>a</item>
<item>b</item>
</alphabet>
<states>
<state>S1</state>
<state>S2</state>
<state>S3</state>
<state>S4</state>
</states>
<init>
<state>S1</state>
</init>
<finals>
<state>S4</state>
</finals>
<arrows>
<arrow>
<state>S1</state>
<state>S2</state>
<item>a</item>
</arrow>
</arrows>
</authomata>
</input>
<output>
<authomata>
<type>
<item>AutomataFD</item>
</type>
<alphabet>
94 TALFi
<item>a</item>
<item>b</item>
</alphabet>
<states>
<state>S10</state>
<state>S43</state>
<state>[S21,S32]</state>
</states>
<init>
<state>S10</state>
</init>
<finals>
<state>S43</state>
</finals>
<arrows>
<arrow>
<state>S10</state>
<state>[S21,S32]</state>
<item>b</item>
</arrow>
</arrows>
</authomata>
</output>
</ejercicio>
Se autoriza a la Universidad Complutense a difundir y utilizar con fines acadmicos, no
comerciales y mencionando expresamente a sus autores, tanto la propia memoria, como
el cdigo, la documentacin y / o el prototipo desarrollado.
Fdo: