TADs en 2 niveles - Clase práctica AED II

TADs en 2 niveles
Clase práctica AED II
28 de Marzo de 2014
()
TADs en 2 niveles
28 de Marzo de 2014
1 / 24
1
Introducción
La clase
La técnica
2
Ejercicio 1
Enunciado
Resolución 1
Resolución 2
3
Ejercicio 2
Enunciado
TAD inferior
TAD superior
4
Extras
()
TADs en 2 niveles
28 de Marzo de 2014
2 / 24
La Clase
Previamente...
Clase 1:
I
I
I
I
I
Definimos observadores e igualdad observacional
Definimos generadores
Axiomatizamos
Definimos y axiomatizamos otras operaciones, en caso de haberlas
Aprendimos que los observadores y generadores deben ser un conjunto minimal
Clase 2: Ejemplos de comportamiento automático
Clase 3: Inducción estructural (no veremos nada relacionado hoy)
Objetivos
Presentar la técnica de modelado en varios niveles de TADs. No tiene
porqué ser algo novedoso.
Analizar cuándo y porqué sirve esta técnica ası́ como el modo de usarla.
()
TADs en 2 niveles
28 de Marzo de 2014
3 / 24
La técnica
Hablamos de TADs en varios niveles cuando definimos TADs que usan otros TADs
internamente. En general, hablamos de TADs en múltiples niveles. Esto se hace
principalmente para:
Agrupar información
Simplificar TADs mediante el uso de otros y sus propiedades
En resumen, hacer que el TAD sea lo más simple y conciso posible, expresando
todo lo que debe expresar.
()
TADs en 2 niveles
28 de Marzo de 2014
4 / 24
¿Qué TADs usamos cuando trabajamos en varios niveles?
TADs básicos
TADs propios
Alguna combinación de ellos
Si nuestra idea es ahorrarnos trabajo y hacer nuestro TAD intuitivo, es
conveniente usar TADs básicos: dado que ya están hechos y son conocidos por
todos. No obstante, esto no siempre es posible.
La clase de hoy muestra ejemplos para ver cuándo y cómo usamos varios niveles, y
qué TADs nos conviene usar.
()
TADs en 2 niveles
28 de Marzo de 2014
5 / 24
Enunciado 1
En la facultad de exactas se decidieron organizar competencias de acertijos matemáticos. Nos
fue encargada la tarea de especificar como funciona el sistema informático que maneja la parte
administrativa del mismo. Las competencias se organizarı́an periódicamente. Los jugadores que
vayan a participar deben inscribirse previo al inicio de la temporada. Los datos de la inscripción
son nombre y carrera y no puede haber dos jugadores con el mismo nombre. Al comenzar la
temporada se cierran las inscripciones a la competencia y se publican los acertijos. Durante el
transcurso de la misma nuevos acertijos pueden ser publicados. Estos se identifican con un
número y no existe distinción relacionada a cuando fueron publicados. Los jugadores deberán
encontrar respuesta a la mayor cantidad de acertijos posible.
Se pide especificar un TAD que modele el comportamiento de una temporada de esta
competencia. Como solo nos incumben las cuestiones administrativas, solo nos
importará registrar cuando un jugador acierta un acertijo, no ası́ los intentos fallidos. Se pide
además conocer en cada momento la cantidad de acertijos acertados por jugador.
()
TADs en 2 niveles
28 de Marzo de 2014
6 / 24
TAD Temporada
géneros
temp
observadores básicos
jugadores : temp −→ conj(nombre)
acertados : temp t × nombre j −→ conj(nat)
iniciada : temp −→ bool
acertijos : temp −→ conj(nat)
carrera : temp t × nombre n −→ carrera
generadores
nuevaTemp : −→ temp
inscribirJugador : nombre n × carrera c × temp t
{j ∈ jugadores(t) ∧ iniciada(t)}
{n ∈ jugadores(t)}
−→ temp
{¬ n ∈ jugadores(t) ∧¬ iniciada(t)}
initTemp : temp t −→ temp
{¬ iniciada(t)}
agregarAcertijo : temp t × nat n −→ temp
{¬ n ∈ acertijos(t)}
anotarAcertijo : temp t × nat n × nombre j −→ temp
{iniciada(t) ∧ j ∈ jugadores(t) ∧L n ∈ (acertijos(t) - acertados(t, j))}
Fin TAD
()
TADs en 2 niveles
28 de Marzo de 2014
7 / 24
axiomas
jugadores(nuevaTemp) ≡ ∅
jugadores(inscribirJugador(n,c,t)) ≡ Ag(n, jugadores(t))
jugadores(initTemp(t)) ≡ jugadores(t)
jugadores(agregarAcertijo(t, n)) ≡ jugadores(t)
jugadores(anotarAcertijo(t, n, j)) ≡ jugadores(t)
acertados(initTemp(t), n’) ≡ ∅
acertados(agregarAcertijo(t, n), n’) ≡ acertados(t, n’)
acertados(anotarAcertijo(t, n, j), n’) ≡ (if n’ = j then Ag(n, ∅) else ∅ fi)
∪ acertados(t, n’)
iniciada(nuevaTemp) ≡ false
iniciada(inscribirJugador(n, c, t)) ≡ false
iniciada(initTemp(t)) ≡ true
iniciada(agregarAcertijo(t, n)) ≡ iniciada(t)
iniciada(anotarAcertijo(t, n, j) ≡ true
()
TADs en 2 niveles
28 de Marzo de 2014
8 / 24
axiomas
acertijos(nuevaTemp) ≡ ∅
acertijos(inscribirJugador(n,c,t)) ≡ acertijos(t)
acertijos(initTemp(t)) ≡ acertijos(t)
acertijos(agregarAcertijo(t, n)) ≡ Ag(n, acertijos(t))
acertijos(anotarAcertijo(t, n, j)) ≡ acertijos(t)
carrera(inscribirJugador(n, c, t), n’) ≡ if n = n’ then c else carrera(t, n’) fi
carrera(initTemp(t), n’) ≡ carrera(t, n’)
carrera(agregarAcertijo(t, n), n’) ≡ carrera(t, n’)
carrera(anotarAcertijo(t, n, j), n’) ≡ carrera(t, n’)
()
TADs en 2 niveles
28 de Marzo de 2014
9 / 24
Veamos ahora otra resolución usando TADs en varios niveles...
()
TADs en 2 niveles
28 de Marzo de 2014
10 / 24
TAD jugador es tupla(nombre, carrera)
TAD Temporada
géneros
temp
observadores básicos
jugadores : temp −→ conj(jugador)
acertados : temp t × jugador j −→ conj(nat)
acertijos : temp −→ conj(nat)
generadores
initTemp : conj(jugador) js × conj(nat) as
{j ∈ jugadores(t)}
−→ temp
Q
Q
Q
Q
{(∀j, j 0 : jugador)({j, j’} ⊆ js ⇒ ¬( 1 (j) = 1 (j’) ∧ 2 (j) 6= 2 (j’)))}
anotarAcertijo : temp t × nat n × jugador j −→ temp
{j ∈ jugadores(t) ∧L n ∈ (acertijos(t) - acertados(t, j))}
agregarAcertijo : temp t × nat n −→ temp
{¬ n ∈ acertijos(t)}
Fin TAD
()
TADs en 2 niveles
28 de Marzo de 2014
11 / 24
axiomas
jugadores(initTemp(js, as)) ≡ js
jugadores(agregarAcertijo(t, n)) ≡ jugadores(t)
jugadores(anotarAcertijo(t, n, j)) ≡ jugadores(t)
acertados(initTemp(js, as), n’) ≡ ∅
acertados(agregarAcertijo(t, n), n’) ≡ acertados(t, n’)
acertados(anotarAcertijo(t, n, j), n’) ≡ if n’ = j
then Ag(n, acertados(t, n’))
else acertados(t, n’)
fi
acertijos(initTemp(js, as)) ≡ as
acertijos(agregarAcertijo(t, n)) ≡ Ag(n, acertijos(t))
acertijos(anotarAcertijo(t, n, j)) ≡ acertijos(t)
()
TADs en 2 niveles
28 de Marzo de 2014
12 / 24
Recién vimos que usar TADs básicos puede simplificar bastante el modelado del
problema... ¿siempre va a alcanzar con hacer esto?
A veces los TADs básicos y su composición no llegan a expresar todo el
comportamiento: aparecen restricciones complicadas a los TADs básicos usados
como parámetro, y operaciones que parecen tener poca relación entre sı́,
perdiendo claridad en la especificación...
Figura: Especificar no deberı́a ser un enredo
()
TADs en 2 niveles
28 de Marzo de 2014
13 / 24
...generalmente es señal de que podemos modularizar el problema en más de un
TAD, modelando ciertas restricciones presentes y/o relaciones entre los datos
involucrados en un TAD a medida, que los encapsule.
Veámoslo mejor con el siguiente ejercicio...
()
TADs en 2 niveles
28 de Marzo de 2014
14 / 24
A pesar del éxito que fueron las competencias matemáticas, la facultad decidió condimentar las
mismas con un nuevo sistema. En esta nueva competencia, los acertijos son categorizados con
un número de complejidad del 1 al 5 y los mismos se organizan de forma laberı́ntica. En este
caso, los acertijos están fijos desde el inicio de la temporada.
El objetivo de la competencia es ser el primero en atravesar el laberinto (ver Cuadro). Todos los
jugadores comienzan con un acertijo inicial. Al resolverlo tienen la posibilidad de avanzar en el
laberinto. Cuando se resuelve un acertijo el jugador obtiene acceso a uno o más acertijos nuevos.
No obstante, el jugador debe elegir con cuál de estos nuevos acertijos quiere enfrentarse. Esta
decisión lo restringe a un camino en el laberinto. Todos los caminos posibles terminan en un
acertijo final. No existen ciclos en el laberinto.
Los jugadores tienen completo conocimiento de las relaciones entre los acertijos y sus
dificultades. La temporada solo termina al ser resuelto el acertijo final y el ganador es quién lo
haga.
()
TADs en 2 niveles
28 de Marzo de 2014
15 / 24
El laberinto de acertijos requerido para una temporada tiene ciertas restricciones:
Hay un único acertijo final y un único
acertijo inicial
Siguiendo un camino del laberinto no
puedo llegar a un acertijo ya resuelto
Cuadro: Ejemplo de un laberinto de acertijos
()
TADs en 2 niveles
28 de Marzo de 2014
16 / 24
Figura: El señor de los laberintos
()
TADs en 2 niveles
28 de Marzo de 2014
17 / 24
Se pide modificar el TAD Temporada para que maneje la nueva información administrativa. Se
debe conocer los acertijos y la relación entre ellos, ası́ como sus dificultades. Además debe
mantener la información sobre los jugadores, en qué acertijo se encuentran y cuáles resolvieron, e
imponer las restricciones del laberinto a la hora de moverse por él. La temporada debe finalizar
cuando un jugador resuelve el acertijo final, luego de esto el jugador pasa a ser el ganador de la
temporada y ningún otro jugador puede resolver acertijos.
()
TADs en 2 niveles
28 de Marzo de 2014
18 / 24
TAD jugador es tupla(nombre, carrera)
TAD Laberinto
géneros
lab
observadores básicos
acertijos : lab −→ conj(nat)
dificultad : lab l × nat a −→ nat
opciones : lab l × nat a −→ conj(nat)
{a ∈ acertijos(l)}
{a ∈ acertijos(l)}
generadores
nuevoLab : nat a × nat d −→ lab
agAcertijo : lab l × nat acj × nat dif × conj(nat) prev
{1 ≤ d ≤ 5}
−→ lab
{prev ⊆ acertijos(l) ∧ 1 ≤ dif ≤ 5 ∧¬ acj ∈ acertijos(l) ∧ #(prev) ≥ 1}
otras operaciones
acertijoInicial : lab −→ nat
acertijosFinales : lab −→ conj(nat)
filtrarAcertijosFinales : lab l × conj(nat) as
−→ conj(nat)
{as ⊆ acertijos(l)}
Fin TAD
()
TADs en 2 niveles
28 de Marzo de 2014
19 / 24
axiomas
acertijos(nuevoLab(a, d)) ≡ Ag(a, ∅)
acertijos(agAcertijo(l, acj, dif, prev)) ≡ Ag(acj, acertijos(l))
dificultad(nuevoLab(a, d), a’) ≡ d
dificultad(agAcertijo(l, acj, dif, prev), a’) ≡ if acj = a’ thendif elsedificultad(l, a’) fi
opciones(nuevoLab(a, d), a’) ≡ ∅
opciones(agAcertijo(l, acj, dif, prev), a’) ≡ if a’ ∈ prev then Ag(acj, ∅) else ∅ fi
∪
if a’ ∈ acertijos(l) then opciones(l, a’) else ∅ fi
acertijoInicial(nuevoLab(a,d)) ≡ a
acertijoInicial(agAcertijo(l, acj, dif, prev)) ≡ acertijoInicial(l)
acertijosFinales(l) ≡ filtrarAcertijosFinales(l, acertijos(l))
()
TADs en 2 niveles
28 de Marzo de 2014
20 / 24
TAD Temporada
géneros
temp
observadores básicos
jugadores : temp −→ conj(jugador)
acertados : temp t × jugador j −→ conj(nat)
actual : temp t × jugador j −→ nat
lab : temp −→ lab
{j ∈ jugadores(t)}
{j ∈ jugadores(t)}
generadores
initTemp : conj(jugador) js × lab l −→ temp
Q
Q
Q
Q
(∀j, j 0 : jugador)({j, j’} ⊆ js ⇒ ( 1 (j) = 1 (j’) ∧ 2 (j) 6= 2 (j’))) ∧
#(acertijosFinales(l)) = 1
anotarYproxAcertijo : temp t × jugador j × nat elec −→ temp
j ∈ jugadores(t) ∧L ¬ actual(t, j) ∈ acertijosFinales(laberinto(t)) ∧ elec
∈ opciones(laberinto(t), actual(t, j)) ∧ ¬ finalizada(t)
anotarAcertijoFinal : temp t × jugador j −→ temp
{j ∈ jugadores(t) ∧ actual(t, j) ∈ acertijosFinales(laberinto(t))}
otras operaciones
finalizada : temp
−→ bool
Fin TAD
()
TADs en 2 niveles
28 de Marzo de 2014
21 / 24
axiomas
jugadores(initTemp(js, l)) ≡ js
jugadores(anotarYproxAcertijo(t, n, j)) ≡ jugadores(t)
jugadores(anotarAcertijoFinal(t, j)) ≡ jugadores(t)
acertados(initTemp(js, l), j’) ≡ ∅
acertados(anotarYproxAcertijo(t, j, elec), j’) ≡ if j’ = j then
Ag(actual(t, j), acertados(t, j’))
else
acertados(t, j’)
fi
acertados(anotarAcertijoFinal(t, j), j’) ≡ if j’ = j then
Ag(actual(t, j), acertados(t, j’))
else
acertados(t, j’)
fi
actual(initTemp(js, l), j’) ≡ acertijoInicial(l)
actual(anotarYproxAcertijo(t, j, elec), j’) ≡ if j = j’
then elec
else actual(t, j’)
fi
actual(anotarAcertijoFinal(t, j), j’) ≡ actual(t, j’)
()
TADs en 2 niveles
28 de Marzo de 2014
22 / 24
axiomas
lab(initTemp(js, l)) ≡ l
lab(anotarYproxAcertijo(t, j, elec)) ≡ lab(t)
lab(anotarAcertijoFinal(t, j)) ≡ lab(t)
finalizada(initTemp(js, l)) ≡ false
finalizada(anotarYproxAcertijo(t, j, elec)) ≡ false
finalizada(anotarAcertijoFinal(t, j)) ≡ true
()
TADs en 2 niveles
28 de Marzo de 2014
23 / 24
Axiomas de los acertijos finales del Laberinto
acertijosFinales(l) ≡ filtrarAcertijosFinales(l, acertijos(l))
filtrarAcertijosFinales(l, as) ≡ if ∅?(as)
then as
else(
if ∅?(opciones(dameUno(as), l))
then Ag(dameUno(as),∅)
else ∅
fi
∪ filtrarAcertijosFinales(l,sinUno(as))
)
fi
()
TADs en 2 niveles
28 de Marzo de 2014
24 / 24