REDESCUBRIENDO GOLD 3 - repositorio.uniandes.edu.co

1

REDESCUBRIENDO GOLD 3

OTRO PUNTO DE VISTA DEL LENGUAJE DE PROGRAMACIÓN ORIENTADO A GRAFOS

AUTOR

FABIO DAVID GUEVARA BARRIENTOS

UNIVERSIDAD DE LOS ANDES

ASESORA

SILVIA TAKAHASHI RODRÍGUEZ, PH.D.


PROYECTO DE GRADO

DEPARTAMENTO DE INGENIERÍA DE SISTEMAS Y COMPUTACIÓN

FACULTAD DE INGENIERÍA


BOGOTÁ D.C., COLOMBIA

AGOSTO 3 DE 2015

2

Tabla de contenidos

1 Resumen ..................................................................................................................................... 2

2 Introducción ................................................................................................................................. 3

3 Objetivos ...................................................................................................................................... 3

4 Antecedentes ............................................................................................................................... 4

4.1 Versiones anteriores a GOLD 3 .................................................................................................. 4

4.2 GOLD 3 ........................................................................................................................................ 4

3 Diseño y especificaciones ........................................................................................................... 5

3.1 Definición del problema ............................................................................................................... 5

3.2 Estructura del proyecto ................................................................................................................ 5

3.3 Sintaxis ........................................................................................................................................ 6

4 Desarrollo del diseño ................................................................................................................... 7

4.1 Recolección de información ........................................................................................................ 7

4.2 Implementación ........................................................................................................................... 8

5 Resultados ................................................................................................................................... 9

5.1 Descripción de resultados ........................................................................................................... 9

5.2 Ejemplos .................................................................................................................................... 10

6 Conclusiones ............................................................................................................................. 14

6.1 Trabajo desarrollado .................................................................................................................. 14

6.2 Trabajo futuro ............................................................................................................................ 14

8 Referencias................................................................................................................................ 14

3

1 RESUMEN

El lenguaje de programación imperativo GOLD (Graph Oriented Language Domain) es usado en la Universidad de los Andes para la clase Lenguajes y máquinas, los estudiantes lo usan para la creación de los distintos tipos de autómatas enseñados. Ya que hacen sus ejercicios con esta herramienta, es deseable que sea de una forma más amigable y eficiente para que sea posible ampliar el rango de posibilidades en las tareas asignadas y por esto se ha mejorado la estructura de los métodos usados en un área específica, los autómatas de pila, además de encontrar formas de implementar autómatas grandes con el uso de ciclos y tuplas, y también facilitar un futuro proceso de mejora a este proyecto.

2 INTRODUCCIÓN

Desde que se hizo la versión GOLD 3, se introdujo en los ambientes de trabajo para estudiantes de Lenguajes y máquinas, siendo la herramienta por excelencia para hacer autómatas finitos, de pila y de Turing. Sin embargo, tiene limitaciones y, sobre todo, cierta incomodidad para escribir algunas de las instrucciones. El proyecto GOLD tiene mucho potencial, pero hay que hallar la forma de explotarlo.

Al tener la oportunidad de trabajar con este lenguaje se notaron algunas cosas que se podrían corregir, como la gramática para algunas instrucciones, redundancias y, en ocasiones, pequeña concordancia con el funcionamiento y entendimiento de lo que es un autómata de pila, sobre todo de su construcción. Esto no se vio como problemas como tal, sino como oportunidades de mejora para el trabajo que se había terminado en el 2012. Es así como la forma de atacar el problema sería empezar por introducirse en la construcción del proyecto y ver cuál sería el punto donde se pueden hacer mejoras de una forma directa y sin afectar a la gramática, dónde está el core funcional de GOLD.

Una vez obtenido el suficiente conocimiento del lenguaje, se reconoció al módulo de estructuras como el eje de las acciones. Allí se enfocarían los esfuerzos para poder mejorar el tema de la concordancia con la construcción de los autómatas de pila y también para solucionar inconvenientes con los tipos de datos que se usan, pues hay que convertirlos previamente para que el autómata pueda aceptar los estados y símbolos leídos. En específico, para los autómatas de pila, existe una clase llamada GPushdownAutomaton donde está la estructura de datos general para las pilas, donde se describen las transiciones y las funciones que tiene una pila.

El resultado de los esfuerzos hechos es un lenguaje más sencillo de entender y menos complejo con el que implementar un autómata de pila, es aún más cómodo que en la versión de GOLD previa, sobre todo si tiene una gran diversidad en el manejo de tipos de datos y también si es de gran tamaño. Al final de esto se crea una librería en formato JAR que se puede instalar en el entorno de desarrollo Eclipse como un plugin y estará interpretando el lenguaje de grafos.

3 OBJETIVOS

- Hacer del lenguaje GOLD para autómatas de pila más concordante con la lógica de la construcción de estas máquinas.

- Permitir que el lenguaje sea más flexible, estando menos ligado al tipo de datos que se usen y también permitiendo un aumento de instrucciones más fácil, de modo que se vuelve más extensible.

- Explorar la estructura del lenguaje, cómo funciona y cómo se puede extender, de modo que para futuros trabajos sea más sencillo de implementar ahorrando la parte de reingeniería.

4

4 ANTECEDENTES

4.1 Versiones anteriores a GOLD 3

4.1.1 CSet

Tésis de maestría realizada por Víctor Hugo Cárdenas en 2008 con asesoría de Silvia Takahashi del departamento de Ingeniería de Sistemas y Computación en la Universidad de los Andes. Es un lenguaje de programación declarativa cuya función principal es manejar conjuntos de datos y permitir operaciones sobre estos. Ya que su enfoque era el manejo de los datos como conjuntos, sirvió como base para desarrollar un lenguaje de grafos, ya que para esto se necesitan definir conjuntos de estados, transiciones y, para los autómatas, el lenguaje que se va a interpretar.

CSet fue desarrollado usando el framework Eclipse Modeling Project, o como era llamado en el tiempo en que se hizo, openArchitectureWare (oaW). OAW se encargaba de administrar Xtext, herramienta usada para definir la gramática de CSet.

4.1.2 GOLD 1

En el 2009, en manos de Luis Miguel Pérez para su tesis de pregrado con la asesoría de Silvia Takahashi del departamento de Ingeniería de Sistemas y Computación y Andrés Medaglia del departamento de Ingeniería Industria, ambos de la Universidad de los Andes, el proyecto GOLD (Graph Oriented Language Domain) usó las facilidades que proveía CSet para el manejo de conjuntos. Con los conjuntos se pueden definir los vértices y las transiciones de los grafos haciendo uso de términos matemáticos (ausentes en CSet).

GOLD se hizo como una alternativa que cubría los espacios que dejaban las herramientas de grafos existentes en el momento, pues era difícil en éstas definir vértices y arcos sin elementos matemáticos, dejando como única alternativa simplemente decir uno por uno los elementos. Con GOLD 1 es posible definir conjuntos con propiedades matemáticas o simplemente por enumeración, aunque todos los elementos deben tener el mismo tipo de dato, estando disponibles

las cadenas de caracteres (String), enteros (int), reales (real), booleanos (boolean), tuplas

(sin identificador), conjuntos (Set) y grafos (Graph). Además de permitir operaciones matemáticas,

también podía exportar y visualizar los grafos.

4.1.2 GOLD 2 (GOLD+)

La versión de GOLD 1 suponía un gran avance para el manejo de grafos, pero solo permitía la definición de estos además de unas cuantas operaciones matemáticas, se necesitaba la opción de poder manejarlos. Diana Mabel Díaz, en el 2010, enfocó sus esfuerzos en la tesis de maestría para lograr un lenguaje capaz de tener esta funcionalidad, con la asesoría de Silvia Takahashi, para hacer GOLD+ (o GOLD 2 en el documento del proyecto). Esta extensión de GOLD 1 permite un manejo básico de grafos con ciertas instrucciones de control, pero nada complejo.

GOLD 2 permitió añadir atributos a los vértices y arcos, se pueden crear funciones y se pueden

usar las instrucciones foreach (para ejecutar un conjunto de acciones sobre los nodos de un

grafo) e if-then (para ejecutar un conjunto de acciones si se cumple alguna condición). Cabe

notar que esta última instrucción no tenía las cláusulas else ni elseif.

4.2 GOLD 3

En la versión 3 de GOLD, hecha por Alejandro Sotelo para su tesis de maestría con la asesoría de Silvia Takahashi del departamento de Ingeniería de Sistemas y Computación, se hicieron grandes

5

avances en el lenguaje. Teniendo las instrucciones de GOLD 2 para manejo de grafos y la creación de funciones, tuvo bastantes adiciones como:

- Cuantificadores para la escritura de expresiones lógicas como la sumatoria, multiplicatoria, conjunción y disyunción.

- Tipos de datos, como números racionales y complejos. Cabe resaltar que GOLD 3 deja de ser un lenguaje fuertemente tipado como la versión anterior.

- Estructuras de datos como tuplas, listas, pilas, colas, árboles y autómatas (deterministas y no deterministas).

- Operadores para manipular números, expresiones booleanas, conjuntos y otros.

- Declaración de funciones con retorno y procedimientos sin retorno.

- Entorno de programación amigable que resalta los errores y tiene coloración de sintaxis, indentación y una tabla de símbolos Unicode para insertar en el código.

- Interfaz gráfica para visualización y manejo de grafos en ejecución.

- Permite el uso de clases implementadas en Java y funciones declaradas en otros archivos.

Además de tener estas adiciones, también permite las funciones recursivas (ausente en GOLD+), importante para la implementación de algoritmos sobre grafos como el recorrido por profundidad, además exige que los parámetros sean valores y no referencias, Finalmente, lo más evidente de la nueva versión es que significa una gran mejora para el entendimiento y la misma escritura de los proyectos.

3 DISEÑO Y ESPECIFICACIONES

3.1 Definición del problema

En la Universidad de los Andes se utiliza GOLD como método de implementación de autómatas en la clase de Lenguajes y máquinas. También el lenguaje sirve para personas de distintas disciplinas relacionadas con la ingeniería y las matemáticas para la resolución de problemas, y, sobre todo, problemas que pueden ser definidos como grafos cuyos problemas tienen una solución ya implementada en algoritmos que se encuentran fácilmente.

En la versión 3.1.3 de GOLD se hicieron avances importantes para el manejo de grafos y, en específico, para la creación, manipulación y simulación de autómatas. Sin embargo, todavía quedan áreas donde se puede mejorar el lenguaje, mejorando la lectura y facilitando en distintos casos la implementación. El problema que se atacará será el uso de diferentes tipos de dato para la manipulación de los autómatas, de modo que independientemente del tipo de dato que se maneje, no se requiera hacer conversiones.

3.2 Estructura del proyecto

La implementación del proyecto GOLD se programó en Xtext, una herramienta de desarrollo de lenguajes de código abierto para el entorno de desarrollo Eclipse. Se basa en un analizador sintáctico o parser que se encarga de interpretar el lenguaje con unas reglas sintácticas y

6

semánticas definidas en Xtext que están hechas especialmente para el manejo de grafos, así haciendo una ‘traducción’ a Java y finalmente siendo éste el lenguaje con el que funcionará todo por debajo. También se usaron estructuras de datos personalizadas hechas en Java para facilitar el manejo de la información y todo aquello relacionado con los autómatas y grafos en general.

El trabajo hecho se enfoca en el subproyecto de estructuras, pues aquí es donde se hicieron los

cambios relevantes. La estructura afectada por las modificaciones fue GPushdownAutomaton, es

decir, la de autómata de pila.

3.3 Sintaxis

3.3.1 Tipos de datos

Los tipos de datos de GOLD comprenden los conjuntos matemáticos básicos (booleanos, números

naturales, enteros, racionales, reales y complejos) y los heredados de Java (boolean, char,

byte, short, int, long, float y double). A su vez, están los tipos compuestos, es

decir, las clases Java. En este proyecto se trata con algunos tipos de Java y con los tipos

compuestos de String, GPushdownAutomaton y una subclase de éste, GPushdownDelta.

3.3.2 Métodos

Se pueden invocar métodos de una clase Java y esto es lo que se hace para definir las transiciones del autómata de pila. En GOLD 3 los métodos para describir las transiciones eran:

- GPushdownAutomaton

o delta(q1, q2, s), que crea una transición desde el estado q1 al estado q2

recibiendo la cadena s. Esto retorna un objeto de tipo GPushDownDelta.

- GPushdownDelta

o push(g), que inserta en la pila la cadena g.

o pop(g), que saca del tope de la pila la cadena g.

o ignore(), que no hace nada.

o pushOn(g, s), que inserta la cadena g en la pila si está la cadena s en el tope.

7

o skip(s), que no hace nada si la cadena s está en el tope.

o changeTop(g, s), que saca del tope de la pila la cadena s para insertar la

cadena g.

Luego de haber hecho los cambios, los métodos para describir las transiciones son:

- GPushdownAutomaton

o delta(q1, s), que crea una transición desde el estado q1 cuando lee la cadena

s. Esto retorna un objeto de tipo GPushDownDelta.

- GPushdownDelta

o exe(q2, action), que le asigna el estado q2 como final a la transición

ejecutando action, el cual es una cadena especial que trae el nombre del

comando a ejecutar y los parámetros que necesitan, de modo que action tendrá

la siguiente forma:

push g

pop g

ignore

pushon g s

skip s

changetop g s

Los parámetros se separan con espacio y los nombres de los comandos no distinguen mayúsculas de minúsculas.

4 DESARROLLO DEL DISEÑO

Para este proyecto primero se identificaron características que se podían mejorar del lenguaje, ya que teniendo un objetivo definido sería más dinámico el proceso de reingeniería que se quería desde el principio. Una vez determinada la problemática, se empezó una etapa de exploración y pruebas haciendo cambios mínimos en el lenguaje para la familiarización. Finalmente se aclaró qué meta sería alcanzable basándonos en lo probado y conocido para empezar con la implementación real.

4.1 Recolección de información

La finalidad del proyecto al empezar era hacerle cambios de sintaxis al lenguaje de modo que la estructura de las sentencias fuera más lógico con respecto a la forma de hacerlo a mano. Para iniciar se hicieron pruebas de varios autómatas de pila con distintas formas de agregar los estados, incluyendo diferentes tipos de dato en los parámetros y por ciclos, ya que esto último era la mayor preocupación, pues no se sabía si era posible agregar estados y transiciones en pocas líneas en vez de agregar uno por uno. Sin embargo, la opción ya estaba, así que se buscaron más oportunidades de mejora, la más destacada un cambio de sintaxis por uno más sencillo.

8

Para un cambio de sintaxis era necesario entender la estructura y el funcionamiento de Xtext, así que la primera tarea fue hacer tutoriales para aprender a manejar la herramienta. Después se hicieron pruebas sencillas como el orden de los parámetros de las funciones. En cuanto a bibliografía, el documento de tésis de Alejandro Sotelo donde está la descripción completa del desarrollo de GOLD 3 tenía la información necesaria, pues era la única fuente donde había literatura del lenguaje.

4.2 Implementación

4.2.1 Descripción

Para que un lenguaje de programación pueda usarse (es decir, que se pueda desarrollar en este lenguaje) es muy importante que tenga un IDE (integrated development environment) o ambiente de desarrollo que sea fácil de usar y ayude con la tarea. Ya que GOLD está hecho con el framework Xtext, que se usa en el ambiente Eclipse. Con estas dos herramientas en conjunto se facilitó la tarea de mejorar el lenguaje, pues ya trae características útiles como el resaltado de sintaxis, indentamiento, resaltado de errores, las sugerencias de funciones y completado automático de código.

El lenguaje también tiene su núcleo, que es donde tiene los componentes para compilarlo: el analizador semántico, sintáctico y léxico. Ya que el analizador léxico y sintáctico lo genera Xtext a partir de las reglas propuestas en su creación, solo hay que tratar con el semántico. En el comienzo se quería cambiar la sintaxis del lenguaje, pero al profundizar en la estructura del proyecto, se estableció que no era una meta fácil de alcanzar, puesto que eso implicaba no solo afectar a la sintaxis sino todo el lenguaje y casi rehacerlo. El analizador semántico es el

componente que traduce de GOLD a Java. Cada vez que recibe un archivo .gold, se ejecuta un

análisis léxico y sintáctico, luego se hace el análisis semántico para escribir finalmente el

archivo .java con el código traducido.

Finalmente, GOLD también hace uso de librerías que proveen distintas funcionalidades y apoyan vastamente al lenguaje. Entre ellas se encuentran JUNG (Java Universal Network/Graph Framework), que sirve para el modelado y visualización de grafos; JGraphT, que contiene clases y algoritmos para teoría de grafos; Cormen et al, que tiene implementaciones de estructuras de datos para referenciar; Apfloat para desarrollo de operaciones aritméticas de precisión arbitraria. Las estructuras de datos modificadas para GOLD se encuentran en el proyecto

org.gold.dsl.lib, en el paquete gold.structures. Las modificaciones realizadas se

encuentran en el subpaquete automaton, que contiene las clases GPushdownAutomaton con la

subclase GPushdownDelta además de sus respectivas interfaces, IPushdownAutomaton e

IPushdownDelta.

4.2.2 Resultados esperados

Al iniciar con el proyecto se esperaba cambiar la sintaxis del lenguaje de forma que fuera más sencilla en cuanto a la lectura y el desarrollo, además de solucionar los problemas con los tipos de dato que podían resultar en sentencias muy largas y tediosas y así hacer de GOLD una herramienta algo más flexible. La segunda meta, y la principal, era entender el funcionamiento interno de los autómatas de pila para que en el futuro se pudieran implementar mejoras sin tener que pasar por el trabajo de reingeniería de nuevo.

Los resultados prácticos que se habían previsto eran:

a) Cambiar los métodos push, pushOn, pop, skip, ignore y changeTop por un solo

método de ejecución.

b) Solucionar los problemas con tipos de dato que daban como resultado transiciones de la siguiente forma:

9

M.delta(2,⟨3,Character.valueOf(σ)⟩,String.valueOf(Character.valueOf(σ))).ignore()

i. En el segundo parámetro del delta (⟨3,Character.valueOf(σ)⟩) hay que

poner el Character.valueOf debido a que σ es, en este caso, un carácter que

está siendo tratado como un entero debido a que está dentro del ciclo for σ =

'a' to 'b', que causa que transforme los caracteres a enteros para poder ser

recorridos.

ii. En el tercer parámetro del delta (String.valueOf(Character.valueOf(σ)))

está sucediendo lo mismo que en el segundo parámetro, hay que convertir el entero a carácter que está siendo interpretado así para efectos del ciclo, y posteriormente transformarlo a una cadena de caracteres, pues el método solo

acepta un String.

c) Modificar la sintaxis del lenguaje, de modo que no hubiera que crear el delta por cada transición cuando el autómata tuviera varias transiciones para un mismo símbolo leído, sino que fuera de la forma:

M.delta(1, ""):

push(2, "$")

pop(3, "0")

pop(3, "0")

Lo cual en GOLD 3 sería escrito:

M.delta(1, 2, "").push("$")

M.delta(1, 3, "").pop("0")

M.delta(1, 3, "").pop("0")

5 RESULTADOS

5.1 Descripción de resultados

En la clase GPushdownAutomaton se modificó el método delta(V pInput, V pOutput,

String pPrefix) a delta(V pInput, Object pPrefix), lo cual solucionó el punto b.ii de

los resultados esperados, ya que dentro del método delta se fuerza a que siempre el objeto

pPrefix recibido sea convertido a cadena, librando de esta responsabilidad al programador.

En la clase GPushdownDelta se creó un método exe(V pOutput, String action) que

engloba los métodos mencionados en el punto a de los resultados esperados, de modo que los

llama internamente cuando el parámetro action así lo describe.

Con estos dos puntos también se cambia la estructura de los métodos, haciendo que sea más lógico para una persona que no ha trabajado con autómatas programados, sino solo “en papel”, pues concuerda más con la forma de pensar al crear un autómata.

El punto b.i no se logró, pues finalmente se eliminó de los objetivos debido a que esto implicaba adentrarse más en el analizador semántico, lo cual estaba fuera del dominio del trabajo de reingeniería hecho. El punto c estaba incluso más fuera del alcance, porque no solo había que

10

modificar el analizador léxico-sintáctico sino además el semántico, lo que probablemente no se podría hacer en el trabajo de 4 meses.

5.2 Ejemplos

5.2.1 Autómata de pila para el lenguaje 𝐿 = {𝑎𝑛𝑏𝑛|𝑛 > 0}

Código 5.1. Autómata de pila para lenguaje 5.2.1 en GOLD 3.2.

function createAutomaton():IPushdownAutomaton begin

Q:={1,2} Σ:={'a','b'} Γ:={'1'}

q₀:=1 F:={2}

M:=GPushdownAutomaton(Q,Σ,Γ,q₀,F) M.delta(1,"a").exe(1,"push a") M.delta(1,"b").exe(2,"pop a") M.delta(2,"b").exe(2,"pop a")

return M end

Figura 5.1. Imagen generada por GOLD del autómata para lenguaje 5.2.1.

11

5.2.2 Autómata de pila para el lenguaje sobre el alfabeto {𝑎, 𝑏} cuya longitud es impar y donde 𝑎 es el símbolo de la mitad de la cadena.



Q:={1,2} Σ:={'a','b'} Γ:={'1'}

q₀:=1 F:={2}

M:=GPushdownAutomaton(Q,Σ,Γ,q₀,F) M.delta(1,"a").exe(1,"push 1") M.delta(1,"b").exe(1,"push 1") M.delta(1,"a").exe(2,"ignore") M.delta(2,"a").exe(2,"pop 1") M.delta(2,"b").exe(2,"pop 1") return M end


12

5.3.3 Autómata de pila para palíndromos con todo el alfabeto.



Q:={0,1,2,3}

Σ:=('a'‥'z')

Γ:=('a'‥'z')∪{'$'}

q₀:=0 F:={3}

M:=GPushdownAutomaton(Q,Σ,Γ,q₀,F) M.delta(0,"").exe(1,"push $") M.delta(1,"").exe(2,"ignore") M.delta(2,"").exe(3,"pop $")

for σ = 'a' to 'z' do

M.delta(1,Character.valueOf(σ)).exe(1, "push " + Character.valueOf(σ))

M.delta(1,Character.valueOf(σ)).exe(2, "ignore")

M.delta(2,Character.valueOf(σ)).exe(2, "pop " + Character.valueOf(σ))

end

return M end

13


14

6 CONCLUSIONES

6.1 Trabajo desarrollado

Desde la concepción de GOLD, y aún más en su versión 3, se resuelven muchas de las dificultades que existían para manipular grafos de forma que se pudieran desarrollar proyectos grandes codificando algoritmos en términos matemáticos. Desde GOLD+ a GOLD 3 fue un gran salto en todos los aspectos, siendo más práctico, más fácil de aprender, implementar y leer y con una herramienta de visualización muy útil y necesaria. Aun así, está lejos de ser perfecto y tiene mucho campo para mejorar para facilitar el uso y hacerlo más atractivo no solo para la comunidad de la Universidad de los Andes sino para entes externos.

También se reflejó en el trabajo hecho que se pueden hacer cambios que podrían considerarse de sintaxis, pero en realidad son llamados de métodos de Java, y puede mejorarse la forma de desarrollar, la expresividad y minimizar la verbosidad con solo modificar las estructuras de datos que se usan en GOLD, pues así como se pudo hacer con los autómatas de pila, puede también hacerse con los de estados finitos y las máquinas de Turing de ser necesario. No hay que olvidar que este trabajo fue en su mayor parte de reingeniería, por lo que este proyecto debe tomarse como una referencia para aquellas personas que quieran saber aquello que se puede lograr modificando el subproyecto de estructuras y no como una gran evolución del lenguaje como tal, lo que se podría llegar a lograr en un futuro con la investigación realizada más un entendimiento mayor del analizador léxico-sintáctico y el semántico para hacer reformas globales.

6.2 Trabajo futuro

El potencial de GOLD para ser mejorado es amplio, no solo en el campo de autómatas sino el lenguaje en general. Alejandro Sotelo, en el documento de tesis, sugirió atacar los temas de documentación (web para plugin instalable, manual y tutorial, Javadoc de librerías e implementación, pruebas unitarias), implementación (extensiones, redes de Petri, gráficas más potentes, optimización, mezcla con C++, estructuras de datos) e investigación. Entre estas mejoras potenciales, dentro del área de implementación se encontraría:

- Agrupación de estados y transiciones de autómatas. Al implementar autómatas con grupos de estados o transiciones que manejan diferente símbolo pero tienen el mismo funcionamiento, como por ejemplo un autómata que recibe una letra del alfabeto (dos estados, una transición para cada letra), cuando se va a mostrar gráficamente, muestra las n transiciones dependiendo del tamaño del alfabeto. En vez de esto, se podría dibujar dos estados con una transición que generalice, por

ejemplo σ = {'a'..'z'}. Lo mismo sucedería con múltiples estados con mismo funcionamiento.

- Facilitar el uso de diversos tipos de datos en el caso de la creación de estados cuya definición ha

sido con una tupla o con un set. Actualmente, si se crean estados que son tuplas, por ejemplo <1,

a> y <2, a>, hay que hacer, si se requiere, hacer una conversión de tipos para que concuerde

con los tipos de datos en las tuplas. Esto es particularmente necesario al recorrer caracteres (para

el ejemplo anterior: for σ = 'a' to 'b' do … end), pues se convierten automáticamente en

enteros y se necesita hacer la conversión.

8 REFERENCIAS

Sotelo, A.. (2012). GOLD 3 - Un lenguaje de programación imperativo para la manipulación de grafos y otras estructuras de datos. Recuperado de

15

https://sistemas.uniandes.edu.co/~isis1106/dokuwiki/lib/exe/fetch.php?media=tutoriales:gold3_documento.pdf



Documents

REDESCUBRIENDO GOLD 3 - repositorio.uniandes.edu.co