Tipos lineales I. Tipos Lineales 2

Transcripción

1 Tipos Lineales

2 Tipos lineales I En los ordenadores la información se almacena normalmente de manera secuencial: secuencias de bits, secuencias de bloques, secuencias de registros,... En muchos lenguajes (Prolog, Haskell,...) se incorpora un tipo lista predefinido para facilitar la organización secuencial de la información. Las listas se corresponden con las sucesiones finitas de valores de un mismo tipo. Un tipo lista obedece a alguno de los patrones siguientes: Lista = Nil Elt Lista ó ListaNv = Elt Elt ListaNv Los tipos lineales admiten una generación similar a las listas y se diferencian en las operaciones adicionales. Tipos Lineales 2

3 Tipos lineales II Cada tipo lineal utiliza: Un criterio para la formación de las secuencias que siempre se puede reducir al de las listas. Un criterio para acceder a los componentes de una secuencia: primero, último, actual, cualquiera. Un criterio para eliminar elementos: primero, último, actual, cualquiera. Según sean estos criterios tendremos distintos tipos lineales: Pilas (acceso y eliminación del último elemento) Colas (acceso y eliminación del primer elemento) Anillos (acceso y eliminación del elemento actual) Cadenas (acceso y eliminación de cualquier elemento) Tipos Lineales 3

4 Pilas (fmod PILA [X :: TRIV] is sorts Pila[X] PilaNv[X]. subsort PilaNv[X] < Pila[X]. op pilav : -> Pila[X] [ctor]. op apilar : Elt.X Pila[X] -> PilaNv[X] [ctor]. op cima : PilaNv[X] -> Elt.X. op desapilar : PilaNv[X] -> Pila[X].... endfm) pilav apilar(e1,pilav) apilar(e2,apilar(e1,pilav))... Tipos Lineales 4

5 Colas (fmod COLA [X :: TRIV] is sorts Cola[X] ColaNv[X]. subsort ColaNv[X] < Cola[X]. op colav : -> Cola[X] [ctor]. op encola : Elt.X Cola[X] -> ColaNv[X] [ctor]. op primero : ColaNv[X] -> Elt.X. op avanzar : ColaNv[X] -> Cola[X].... endfm) colav encola(e1,colav) encola(e2,encola(e1,colav))... Tipos Lineales 5

6 Anillos (fmod Anillo [X :: TRIV] is sorts Anillo[X] AnilloNv[X]. subsort AnilloNv[X] < Anillo[X]. op anillov : -> Anillo[X] [ctor]. op enganchar : Elt.X Anillo[X] -> AnilloNv[X] [ctor]. op actual : AnilloNv[X] -> Elt.X. op avanzar retroceder : Anillo[X] -> Anillo[X]. op desenganchar : Anillo[X] -> Anillo[X].... endfm) anillov enganchar(e1,anillov) enganchar(e2,enganchar(e1,anillov))... Tipos Lineales 6

7 Listas Genéricas I (fmod LISTA [X :: TRIV] is including MACHINE-INT. sorts Lista[X] ListaNv[X]. subsort ListaNv[X] < Lista[X]. op nil : -> Lista[X] [ctor]. op _:_ : Elt.X Lista[X] -> ListaNv[X] [ctor]. op cabeza : ListaNv[X] -> Elt.X. op cola : ListaNv[X] -> Lista[X]. op _++_ : Lista[X] Lista[X] -> Lista[X]. op longitud : Lista[X] -> MachineInt. op tomar_de_ : MachineInt Lista[X] -> Lista[X]. *** lo que se pueda op quitar_de_ : MachineInt Lista[X] -> Lista[X]. *** lo que se pueda Tipos Lineales 7

8 Listas Genéricas II op pos : Elt.X Lista[X] -> MachineInt. *** 0 si no esta op posinm : Elt.X MachineInt Lista[X] -> MachineInt. op inversa : Lista[X] -> Lista[X]. vars E E1 : Elt.X. var N : MachineInt. vars L L1 : Lista[X]. eq cabeza(e:l) = E. eq cola(e:l) = L. eq nil ++ L = L. eq (E:L) ++ L1 = E : (L ++ L1). eq longitud(nil) = 0. eq longitud(e:l) = 1 + longitud(l). Tipos Lineales 8

9 Listas Genéricas III ceq tomar N de L = nil if N <= 0 or L == nil. ceq tomar N de (E:L) = E:(tomar (N-1) de L) if N > 0. ceq quitar N de L = L if N <= 0 or L == nil. ceq quitar N de (E:L) = quitar (N-1) de L if N > 0. eq pos(e,l) = posinm(e,1,l). eq posinm(e,n,nil) = 0. ceq posinm(e,n,e1:l) = N if E == E1. ceq posinm(e,n,e1:l) = posinm(e,n+1,l) if E =/= E1. eq inversa(nil) = nil. eq inversa(e:l) = inversa(l) ++ (E:nil). endfm) Tipos Lineales 9

10 Ejercicios Definir la operación para invertir listas con ayuda de una función inmersora que utilice un acumulador con una inversa parcial. Demostrar aplicando inducción estructural que L : Lista[X] (L ++ nil = L) Demostrar aplicando inducción estructural que L L1 L2 : Lista[X] ((L ++ L1) ++ L2 = L ++ (L1 ++ L2)) Demostrar aplicando inducción estructural que L L : Lista[X] (inversa(l ++ L ) = inversa(l ) ++ inversa(l)) Tipos Lineales 10

11 Listas de Enteros (view IntM from TRIV to MACHINE-INT is sort Elt to MachineInt. endv) (fmod LISTA-INT is protecting LISTA[IntM]. endfm) Tipos Lineales 11

12 Listas de Listas de Enteros (view LIntM from TRIV to LISTA-INT is sort Elt to Lista[IntM]. endv) (fmod LISTA-LINT is protecting LISTA[LIntM]. endfm) Tipos Lineales 12

13 Listas de números primos I (fmod LISTA-PRIMOS is protecting LISTA[IntM]. op _a_ : MachineInt MachineInt -> Lista[IntM]. op elimmult : MachineInt Lista[IntM] -> Lista[IntM]. op criba : Lista[IntM] -> Lista[IntM]. op primos-hasta : MachineInt -> Lista[IntM]. vars M N : MachineInt. var L : Lista[IntM]. Tipos Lineales 13

14 Listas de números primos II eq M a N = if M > N then nil else M : ((M + 1) a N ) fi. eq elimmult(n, nil) = nil. eq elimmult(n, M : L) = if M % N == 0 then elimmult(n, L) else M : elimmult(n, L) fi. eq criba(nil) = nil. eq criba(m : L) = M : criba(elimmult(m, L)). ceq primos-hasta(n) = nil if N < 1. ceq primos-hasta(n) = 1 : criba(2 a N) if N >= 1. endfm) Tipos Lineales 14

15 Listas Ordenadas I (view Ord from TRIV to TOSET is sort Elt to Elt. endv) (fmod LISTAORD [X :: TOSET] is protecting LISTA[Ord][X]. sorts ListaOrd[X] ListaOrdNv[X]. subsorts ListaOrdNv[X] < ListaNv[Ord][X] ListaOrd[X] < Lista[Ord][X]. op ordenada?_ : Lista[Ord][X] -> Bool. Tipos Lineales 15

16 Listas Ordenadas II op insertar : Elt.X ListaOrd[X] -> ListaOrdNv[X]. op ord-ins : Lista[Ord][X] -> ListaOrd[X]. op mezclar : ListaOrd[X] ListaOrd[X] -> ListaOrd[X]. op ord-mez : Lista[Ord][X] -> ListaOrd[X]. ops minimo maximo : ListaNv[Ord][X] -> Elt.X. op ord-min : Lista[Ord][X] -> ListaOrd[X]. op menores-ig mayores : Lista[Ord][X] -> ListaOrd[X]. op ord-rap : Lista[Ord][X] -> ListaOrd[X].... endfm) Tipos Lineales 16

17 Colas de prioridad (fmod ColaP [X :: TOSET] is sorts ColaPNv[X] ColaP[X]. subsort ColaPNv[X] < ColaP[X]. op colapv : -> ColaP[X] [ctor]. op insertar : Elt.X ColaP[X] -> ColaPNv[X] [ctor]. op min : ColaPNv[X] -> Elt.X. op avanzar-min : ColaPNv[X] -> ColaP[X].... endfm) Tipos Lineales 17

18 Cadenas I (fmod CADENA [X :: TOSET] is protecting MACHINE-INT. sorts Cadena[X] CadenaNv[X] Elt?[X]. subsorts Elt.X < CadenaNv[X] < Cadena[X]. subsort Elt.X < Elt[X]. op * : -> Cadena[X] [ctor]. op : Cadena[X] Cadena[X] -> Cadena[X] [ctor]. vars C1 C2 C3 : Cadena[X]. Var C : CadenaNv[X]. mb C1 C : CadenaNv[X]. mb C C1 : CadenaNv[X]. eq (C1 C2) C3 = C1 (C2 C3). eq * C1 = C1. eq C1 * = C1. Tipos Lineales 18

19 Cadenas II op long : Cadena[X] -> MachineInt. op caracter : MachineInt Cadena[X] -> Elt?[X]. op pos-car : Elt.X Cadena[X] -> MachineInt. op subcadena : MachineInt MachineInt Cadena[X] -> Cadena[X]. op pos-subc : Cadena[X] Cadena[X] -> MachineInt. op _<_ : Cadena[X] Cadena[X] -> Bool. ops pref? suf? subc? : Cadena[X] Cadena[X] -> Bool.... endfm) Tipos Lineales 19

20 Implementación I Para la implementación segura de tipos en un lenguaje de programación es necesario que dicho lenguaje disponga de algún mecanismo de abstracción que permita la ocultación y proteja las estructuras ocultas: Módulos de biblioteca (Modula-2 y C) Interfaz + Implementación Clases (Java) Control de visibilidad para cada componente Tipos Lineales 20

21 Implementación II En lenguajes declarativos, que incorporan el tipo lista como tipo predefinido, los tipos lineales se representan sobre listas implementando sólo las operaciones propias de cada tipo lineal. En lenguajes imperativos (Pascal, Modula2, C, C++), que no permiten la definición directa de estructuras recursivas, hay que utilizar una combinación de registro y puntero a registro para representar los pares (Elt,Lista). Tipos Lineales 21

22 Implementaciones Imperativas I MODULA-2 TYPE Lista = POINTER TO Nodo1; Nodo1 = RECORD ult :Telem; sig :Lista END; C typedef struct Nodo1* Lista; struct Nodo1 {Telem ult; Lista sig}; JAVA class Lista { private Object ult; private Lista sig;... } Tipos Lineales 22

23 Implementaciones Imperativas II En principio, un tipo lineal se puede representar como un puntero a un registro (el último elemento de la estructura). Por cuestiones de eficiencia algunos tipos lineales se definen como registros que contienen varios punteros: La implementación de colas se puede mejorar utilizando un puntero adicional al primer elemento de la cola. La implementación de anillo se puede mejorar utilizando un puntero adicional en cada registro al elemento anterior y conectando el último elemento con el primero y viceversa, para facilitar los giros. Tipos Lineales 23

24 Implementaciones Imperativas III Las operaciones se pueden implementar como funciones o como procedimientos que transforman un argumento. Las operaciones de consulta se suelen implementar como funciones. Las operaciones de transformación (constructoras y operaciones de eliminación de elementos) se implementan como procedimientos que modifican un argumento. Tipos Lineales 24