Características. Tipos Cocientes 2

(1)

(2)

Características

La característica básica de los tipos cocientes es que los distintos

términos construidos con operaciones generadoras no siempre

representan valores distintos del tipo:

Hay que establecer ecuaciones que identifiquen términos

distintos que representan el mismo objeto (términos

equivalente).

Hay que definir las operaciones sobre términos con

constructoras teniendo en cuenta que el resultado debe ser

independiente de la equivalencia de términos.

Los tipos cocientes típicos son aquellos en los que

El orden seguido en la construción incremental de los objetos no

siempre tiene relevancia o

(3)

Multiconjuntos y Conjuntos

(4)

Multiconjuntos I

(fmod MCONJUNTO [X :: TRIV] is protecting MACHINE-INT . sorts MCjNv[X] MCj[X] . subsort MCjNv[X] < MCj[X] . op `{`} : -> MCj[X] [ctor] . op `{_,_`} : Elt.X MCj[X] -> MCjNv[X] [ctor]. op eliminar : Elt.X MCj[X] -> MCj[X] . op card : MCj[X] -> MachineInt .

op multiplicidad : Elt.X MCj[X] -> MachineInt . op esta? : Elt.X MCj[X] -> Bool .

(5)

(6)

Conjuntos I

(fmod CONJUNTO [X :: TRIV] is protecting MACHINE-INT . sorts CjNv[X] Cj[X] . subsort CjNv[X] < Cj[X] . op `{`} : -> Cj[X] [ctor]

.

op `{_,_`} : Elt.X Cj[X] -> CjNv[X] [ctor]. op eliminar : Elt.X Cj[X] -> Cj[X] . op card : Cj[X] -> MachineInt . op esta? : Elt.X Cj[X] -> Bool .

(7)

Conjuntos II

ceq {X1,{X2,C2}} = {X2,C2} if X1 == X2 .

ceq {X1,{X2,C2}} = {X2,{X1,C2}} if X1=/=X2 .

eq eliminar(X2,{}) = {} .

eq eliminar(X2,{X1,C1}) = if X1 == X2 then eliminar(X2,C1) else {X1,eliminar(X2,C1)} fi . eq card({}) = 0 .

eq card({X1,C1}) = 1 + card(eliminar(X1,C1)) . eq esta?(X2,{}) = false .

(8)

Conjuntos III

eq union({},C2) = C2 .

eq union({X1,C1},C2) = {X1,union(C1,C2)} .

eq intersec({},C2) = {} .

eq intersec({X1,C1},C2) =

if esta?(X1,C2) then {X1,intersec(C1,C2)}

else intersec(C1,C2) fi .

eq difer({},C2) = {} .

eq difer({X1,C1},C2) =

if esta?(X1,C2) then difer(C1,C2)

else {X1,difer(C1,C2)} fi .

(9)

Ejercicios

a Especificad la operación de diferencia simétrica entre conjuntos para la especificación dada.

a Especificad una relación de contenido entre conjuntos.

a Enunciad una especificación alternativa de conjuntos utilizando la unión como operación constructora.

(10)

Conjuntos Ordenados I

(fmod CONJUNTOORD [X :: TOSET] is

protecting CONJUNTO[Ord][X] .

protecting LISTA[Ord][X] .

op min : CjNv[X] -> Elt.X .

op listado : Cj[X] -> Lista[Ord][X] .

var X1 : Elt.X .

var C : Cj[X] .

eq min({X1,C}) = if C == {} then X1

else if X1 <= min(C) then X1

else min(C) fi fi .

eq listado(C) = if C == {} then nil

(11)

Funciones y Tablas

Estructuras formadas por asociaciones de

elementos (a->b) en las que no se permiten

dos asociaciones a un mismo elemento y

además, el orden de agregación de

(12)

Funciones Totales

(fmod FUNTOT [D :: TRIV, R :: TRIV] is sort Fun[D,R] .

op funIni : Elt.R -> Fun[D,R] [ctor] .

op _`(_->_`) : Fun[D,R] Elt.D Elt.R -> Fun[D,R] [ctor] . op _`[_`] : Fun[D,R] Elt.D -> Elt.R .

(13)

Funciones Parciales (I)

(fth TRIVERR is

sorts Elt Elt? .

(14)

Funciones Parciales (II)

(fmod FUNPAR [D :: TRIV, R :: TRIVERR] is

sort FunP[D,R] .

op funIni : -> FunP[D,R] [ctor] .

op _`(_->_`) : FunP[D,R] Elt.D Elt.R ->

FunP[D,R][ctor] .

op _`[_`] : FunP[D,R] Elt.D -> Elt?.R .

op borrar : FunP[D,R] Elt.D -> FunP[D,R] .

(15)

(16)

Ejercicios

a _{Especificad una operación: dominio : FunP[D,R] -> Cj[D] que} produzca el conjunto de valores de Elt.D donde está definida una función parcial.

a Enunciad una especificación de funciones parciales para el caso en que el parámetro del recorrido R obedece a una teoría de orden total, añadiendo las operaciones siguientes: ops valMin valMax : FunP[D,R] -> Elt.R que determinen los valores mínimo y máximo de una función parcial, y las operaciones ops ptosMin ptosMax : FunP[D,R] -> Cj[D] .

que determinen los conjuntos de valores de Elt.D donde se alcanza el valor mínimo y el máximo respectivamente.

a Enunciad una especificación para una operación

op agregar : FunP[D,R] FunP[D,R] -> FunP[D,R]

(17)

Tablas

Las tablas son casos particulares de funciones totales con dominio en un

intervalo numérico [0..k-1] o en un producto de intervalos de este tipo,

según sea la dimensión de la tabla.

El hecho de que los dominios de las tablas se puedan ordenar hace que

se puedan encontrar formas canónicas para las tablas y que se puedan

hacer listados de valores. Estas tablas admiten especificaciones más

especializadas que las funciones.

Dentro de las tablas bidimensionales con valores numéricos, cabe

(18)

Tablas I

(fmod TABLA [K :: GRADO, V :: TRIV] is protecting NAT[K] .

protecting LISTA[V] . sort Tabla[K,V] .

op tabIni : Elt.V -> Tabla[K,V] [ctor] .

op _[_/_] : Tabla[K,V] Nat[K] Elt.V -> Tabla[K,V] [ctor] . op _[_] : Tabla[K,V] Nat[K] -> Elt.V .

op valIni : Tabla[K,V] -> Elt.V .

op listado : Tabla[K,V] -> Lista[V] .

op listadoaux : Tabla[K,V] Nat[K] -> Lista[V] .

(19)

Tablas II

ceq T [I1/V1] [I2/V2] = T [I2/V2] if I1 == I2 . ceq T [I1/V1] [I2/V2] = T [I2/V2] [I1/V1] if I2 < I1 . ceq T [I1/V1] [I2/V2] = T [I2/V2] [I1/V1]

if I2 > I1 and V2 == valIni(T) . ceq (tabIni(V1))[I2/V2] = tabIni(V1) if V1 == V2 .

eq (tabIni(V1))[I1] = V1 .

eq (T[I1/V1])[I2] = if I2 == I1 then V1 else T[I2] fi . eq valIni(tabIni(V2)) = V2 .

eq valIni(T[I1/V1]) = valIni(T) . eq listado(T) = listadoaux(T,0) .

eq listadoaux(T,I1) = if I1 == k.K-1 then T[I1] : nil

(20)

Tablas Bidimensionales I

(fmod TABLABD [M N :: GRADO, V :: TRIV] is protecting NAT[M] .

protecting NAT[N] . protecting LISTA[V] . sort Tabla[M,N,V] .

op tabIni : Elt.V -> Tabla[M,N,V] [ctor] .

op _[_ _/_] : Tabla[M,N,V] Nat[M] Nat[N] Elt.V -> Tabla[M,N,V] [ctor] . op _[_ _] : Tabla[M,N,V] Nat[M] NAT[N] -> Elt.V .

op valIni : Tabla[M,N,V] -> Elt.V .

op listado : Tabla[M,N,V] -> Lista[V] .

(21)

Tablas Bidimensionales II

ceq (T[I1 J1/V1])[I2 J2/V2] = T[I2 J2/V2] if I1 == I2 and J1 == J2 .

ceq (T[I1 J1/V1])[I2 J2/V2] = (T[I2 J2/V2]) [I1 J1/V1] if I2 < I1 or (I2 == I1 and J2 < J1) . ceq (tabIni(V1))[I2 J2/V2] = tabIni(V1) if V2 == V1 . ceq (T[I1 J1/V1])[I2 J2/V2] = (T[I2 J2/V2]) [I1 J1/V1]

if (I2=/=I1 or J2=/=J1) and V2==valIni(T) .

eq (tabIni(V1))[I1 J1] = V1 .

eq (T[I1 J1/V1])[I2 J2] = if I2 == I1 and J2 == J1 then V1 else T [I2 J2] fi .

eq valIni(tabIni(V1)) = V1 .

eq valIni(T[I1 J1/V1]) = valIni(T) . eq listado(T) = listadoaux(T,0,0) .

eq listadoaux(T,I1,J1) = if J1 == k.N –1 then

(22)

Matrices Dispersas I

(fmod MATRIZD [N :: GRADO] is protecting NAT[N] .

sort MD[N] . *** solo valores enteros no nulos op matNula : -> MD[N] [ctor] .

op _[__/_] : MD[N] Nat[N] Nat[N] MachineInt -> MD[N] [ctor] . op borrar : Nat[N] Nat[N] MD[N] -> MD[N] .

op _[__] : MD[N] Nat[N] Nat[N] -> MachineInt . op _+_ : MD[N] MD[N] -> MD[N] .

op _*_ : MD[N] MD[N] -> MD[N] . *** operaciones auxiliares:

op multdesde : MD[N] MD[N] Nat[N] Nat[N] -> MD[N] . *** producto fila * columna

(23)

Matrices Dispersas II

vars I1 I2 J1 J2 K : Nat[N] . vars A B : MachineInt . var M1 M2: MD[N] .

ceq M1 [I1 J1/A] [I2 J2/B] = M1 [I2 J2/B]

if I1 == I2 and J1 == J2 . ceq M1 [I1 J1/A] [I2 J2/B] = M1 [I2 J2/B] [I1 J1/A]

if I2 < I1 or (I2 == I1 and J2 < J1) . ceq M1 [I1 J1/A] [I2 J2/B] = M1 [I2 J2/B] [I1 J1/A]

if (I2=/=I1 or J2 =/= J1) and B == 0 . eq matNula[I1 J1/0] = matNula .

eq borrar(I2,J2,matNula) = matNula . eq borrar(I2,J2,M1 [I1 J1/A]) =

if I1 == I2 and J1 == J2 then borrar(I2,J2,M1)

(24)

Matrices Dispersas III

eq M1 + matNula = M1 .

eq M1 + (M2[I1 J1/A]) = (M1 + M2) [I1 J1/(M1[I1 J1]+ A)] . eq M1 * matNula = matNula .

eq M1 * M2 = multdesde(M1,M2,0,0) .

eq M1[I1] ** M2[J1] = iprod(M1,I1,M2,J1,0) . eq iprod(M1,I1,M2,J1,K) =

if K == k.N -1 then (M[I1,K]) * (M [K,J1])

else (M [I1,K]) * (M [K,J1]) + iprod(M1,I1,M2,J1,K+1) fi . eq multdesde(M1,M2,A,B) =

if B == k.N -1 then if A == k.N -1 then matNula [A B/M1[A] ** M2[B]]

Características. Tipos Cocientes 2