Estados

TAD Ajedrez

crearJuego:: Ajedrez

moverFicha:: Ajedrez x Ficha x Posicion x Posicion -> Tablero

TAD Tablero

inicial:: Tablero

mover:: Tablero x Ficha x Posicion x Posicion -> Tablero

esJaqueMate:: Tablero x Jugada -> Bool

TAD Ficha

color

MAIN

Tablero <- Inicial

Blanco <- True

MIENTRAS NO JaqueMate(Tablero)

SI (Blanco) ENTONCES

PRINT “JUGADA JUGADOR BLANCO”

SINO

PRINT “JUGADA JUGADOR NEGRO”

FSI

INPUT Ficha

INPUT PosicionInicio, PosicionFin

T <- Mover (T, Ficha, PosicionInicio, PosicionFin)

Blanco <- NOT(Blanco)

FMIENTRAS

FIN

MAIN

Juego <- crearJuego

MIENTAS NOT (JuegoTerminado)

ObtenerJugada(Ficha, Origen, Destino)

MoverFicha(J, Ficha, Origen, Destino)

FMIENTRAS

jugador <- gano(J)

FIN

Maquina de Estados

Representa un modelado dinamico, donde se basa en estados de esta manera:

Las flechas son operaciones que reflejan un cambio de estado

Las operaciones pueden estar restringidas al estado actual

Desde 1 puedo llamar a mover pero no a calcular

Desde 2 puedo llamar a sumar y calcular pero no a mover

Desde 3 no puedo llamar a nada

La validez de las operaciones depende de la relacion entre estados

representado en este caso por las flechas.

Maquina de estados para el ejemplo de ajedrez

Maquina de estados con meta variables

Solo puede moverse de un estado a otro si el mismo cumple con la condición

Parametrizacion

Materializa estados en base al valor recibido

Transición con transformaciones

A transformación se hace en función de la variable del estado de llegada con asignación del estado
de salida

Volviéndo al ejemplo de Ajedrez

Ejercicio

Dada una luz dimmeable, puede estar encendida. Si está encendida su intensidad puede variar de
0ae

En clase se resolvió también definiendo un valor maximo

TAD Lampara

crear:: Entero -> Lampara

prender:: Lampara -> Lampara

apagar:: Lampara -> Lampara

subir:: Lampara x Entero -> Lampara

bajar:: Lampara x Entero -> Lampara

Op Constructoras

TAD Lampara

Apagado:: Entero x Entero -> Lampara

Prendido:: Entero x Entero -> Lampara

O bien

AP :: Entero x Entero x Bool -> Lampara

Luego implementacion estática

TYPE Lampara = RECORD

enc: Bool

capmax: Entero

intensidad: Entero

END

OTRO EJEMPLO

Codigo Secreto

La maquina palntea una sucesion de colores

El usuario introduce una posible respuesta

Se va a procesar el ingreso del usuario ficha a ficha, no todo junto.

TAD JuegoCS

CONSTRUCTORES

Iniciado :: Lista(Color) x Entero x Entero -> JuegoCS

// tcols tposics tintentos

EnCurso :: Lista(Color) x Entero x Entero x Lista(Color) x Lista(Color) x Entero -> JuegoCS

// tcols tposics tintentos codigo actual_codigo actual_intentos

Perdido :: Lista(Color) x Entero x Entero x Lista(Color)

// tcols tposics tinentos codigo

Ganado :: Lista(Color) x Entero x Entero x Entero -> JuegoCS

OPERACIONES

inicializar :: Lista(Color) x Entero x Entero -> JuegoCS

comenzarPartida :: JuegoCS x Lista(Color)

adivinarColor :: JuegoCS x Color -> JuegoCS x Optional(Entero x Entero x Entero)

Tipos de datos de construcción

Product(A, B, C) = Product(Product(A, B), C)

Either(A, B, C) = Either(Either(A, B), C)

A. B. —>. #(A) = #(B). // Biyeccion

Reglas Sintacitcas

Propiedad: es una propiedad de equivalencia = Reflexiva + Simetrica + Transitiva

Reglas

Aumentacion:

A B. =>

Product(A, C). Product(B, C)

Product(C, A). Product(C, B)

Either(A, C) Either(B, C)

Either(C, A). Either(C, B)

Maybe(A). Maybe(B)

Conmutatividad:

A B. =>

Product(A, B). Product(B, A)

Either(A, B). Either(B, A)

Asociatividad:

A B. =>

Product(Product(A, B), C). Product(A, Product(B, C))

Either(Either(A, B), C) Either(A, Either(B, C))

Siendo f una construccion recursiva:

A. f(A)

B. f(B)

Entonces:

Bool. Maybe(Unit)

Bool. Either(Unit, Unit)

Either(A, A). Product(Bool, A)

Product(Unit, A). A

Unit -> A. A

Product n (A1, ..., An)

Either n (A1, ..., An)

Product1 (A). A

Either1 (A). A

Product0(). Unit

Either0()

Otra Regla

Siendo tipo de dato T con constructores

F1 :: T1 -> T

F2 :: T2 -> T

Fn :: Tn -> T. =>. T. Either(T1, T2, ..., Tn)

Bool

True :: Bool —> True’:: Unit -> Bool

False :: Bool —> False’:: Unit -> Bool

Lista

Lista(a). Either(Unit, Product(a, Lista(a))). Maybe(Product(a, Lista(a)))

Nat

Cero :: Nat

Suc :: Nat -> Nat

Nat Either(Unit, Nat). Maybe(Nat)

Y recordando que Nat. Lista(Unit)

Lista(a). Maybe(Product(a, Lista(a)))

Lista(Unit). Maybe(Product(Unit, Lista(Unit)))

Lista(Unit). Maybe(Lista(Unit))

Nat. Maybe(Nat)

Entonces a nivel implementacion:

Unit: Void

Product: es un record

Either: es un record con switch

Maybe: es un puntero si hay memoria dinamica, sino un Either de Unit y A

Entonces: Lista(a). Maybe(Product(a, Lista(a)))

TYPE Lista(a) = ^ RECORD

Dato: a

 Sig: Lista(a)

END

Distributividad:

Either(Product(A, B), Product(A, C)) Product(A, Either(B, C))

Repaso Parcial

• Arbol N-Ario

Con nodos hoja de un determinado tipo y nodos no hoja de otro tipo de terminado.

Los arcos que unen un elemento con su elemento sucesor pueden tener un rotulo de
eventualmente otro tipo

Se solicita realizar lo siguiente: definir los constructores algebraicos del TDA, explicar con palabras
las validaciones de una posible operacion constructora (parámetros y cartacteristicas)

Definir algebraicamente la operacion depth first dado

Antes de recorrer un nodo hoja o no hoja deberá estar precedido en todos los rótulos des de la raiz
del arbol

Todos los elementos de ...

2) Depth First

5, a, 7, a, c, True, a, 10, a, w, True, a, n, false, 3, d, false

TAD ArbolParcial(h, nh, r) // Hoja / No Hoja

USE Lista

HojaAP :: h -> ArbolParcial(h, nh, r)

NoHojaAP :: nh x Lista(Maybe(r) x ArbolParcial(h, mh, r)) -> ArbolParcial(h, nh, r)

OP CONSTRUCTORAS

construirHoja :: h -> ArbolParcial(h, nh, r)

construirNoHoja :: nh x Lista(Maybe(r),

// NoHojaAP tiene que validar que la lista no sea vacia

OP Constructoras

construirHoja :: h -> ArbolParcial(h, nh, r)

construirHoja :: nh x Lista(Maybe(r) x ArbolParcial(h, nh, r)) -> ArbolParcial(h, nh, r)

construirHoja(x) = HojaAP(x)

construirNoHoja(x, hs) = if esVacia(hs) then ERROR else NoHojaAP(x, hs)

FIN DE LA PRIMERA PARTE Y EMPALME CON LA SEGUNDA PARTE

Either(Product(a, b), Product(a, c)) Product(a, Either(b, c))

Entonces tenemos los tipos monomorficos

Para lo cual se crea un nuevo tipo de dato que generalice atrA. Tipos Polimorficos