A.E.D. 1 Tema 2. Abstracciones y especificaciones. Tema 2. Abstracciones y Especificaciones. 2.1....

A.E.D. 1Tema 2. Abstracciones y especificaciones.

Tema 2. Abstracciones y Especificaciones.

2.1. Introducción.

2.2. Especificaciones informales.2.2.1. Abstracciones funcionales.

2.2.2. Abstracciones de datos.

2.2.3. Abstracciones de iteradores.

2.3. Especificaciones formales.2.3.1. Método axiomático (o algebraico).

2.3.2. Método constructivo (u operacional).


2.1. Introducción: Abstracción

Abstraer: Eliminar lo irrelevante y quedarnos con lo realmente importante.

¿Qué es lo importante?En cada parte del trabajo puede serlo cosas distintas

Para llevar a cabo la abstracción los lenguajes nos proporcionan mecanismos:Módulos, clases, genericidad, ocultación,

encapsulación, ...


2.1. Introducción: Diseño mediante abstracciones

El diseño de programas está basado en el uso de abstracciones. Se trata de:

1. Identificar los subproblemas.

2. Especificación abstracta de cada uno de ellos.

3. Implementar cada abstracción.

4. Verificación del programa.


2.1. Introducción: Mecanismos de abstracción

Abstracción por especificación: Sólo necesitamos conocer qué va a hacer el procedimiento y no cómo funciona. (Encapsulación)

Abstracción por parametrización: Un algoritmo, un tipo, o una variable se definen en base a unos parámetros. (Genericidad)


2.1. Introducción: Tipos de abstracciones

• Abstracciones funcionales Rutinas, procedimientos.– La especificación determina los parámetros de entrada y salida y el

efecto de la ejecución, pero no dice nada de la implementación.

• Abstracciones de datos Tipos Abstractos de Datos.– La especificación determina el comportamiento de las operaciones

definidas, pero no dice nada del almacenamiento de los valores ni de la implementación de las operaciones.

– Las estructuras de datos se usan para almacenar valores de un tipo, y constituyen la concretización de un tipo abstracto.

– Un tipo de datos parametrizado incluye un parámetro que indica el tipo de los objetos almacenados (Lista[T:tipo] puede dar lugar a Lista[Natural] o Lista[Lista[Natural]] según T sea Natural o Lista[Natural])

• Abstracciones de iteradores Iteradores.– Permite realizar un recorrido sobre los elementos de una colección.


2.1. Introducción: Mecanismos de abstracción

Evolución de los lenguajes de programación marcada por la necesidad de incluir nuevos mecanismos de abstracción.

• Lenguajes primitivos: conjunto predefinido de tipos y posibilidad de crear otros nuevos. Engorroso.

• Tipos definidos por el usuario: agrupar variables bajo el nombre del tipo. No se oculta la implementación.

• Módulos: permiten encapsulamiento al agrupar bajo un mismo nombre tipos y las operaciones.

• Clases y objetos. La clase es el tipo definido por el usuario y el módulo donde se encapsulan los datos y operaciones sobre el tipo. Los objetos son instancias de una clase.


2.2. Especificaciones informales.

La descripción de una abstracción se realiza con un lenguaje natural (ambiguas e imprecisas).

Notación de espeficicación:Partes que debe tener la especificación,

Significado y tipo de cada parte,

Partes que pueden ser opcionales, ...


2.2. Especificaciones informales: Abstracciones funcionales

NotaciónOperación <nombre> (ent <id>: <tipo>;...; sal <tipores>)

Requiere: establece restricciones de uso.Modifica: identifica los datos de entrada que se modifican.Calcula: descripción textual del resultado de la operación.

Requiere y Modifica, y los parámetros de entrada y salida son opcionales.

Puede ser parametrizada:

Operación <nombre> [<id>:<tipo>;...] (...



Ejemplo 1: eliminar la repetición en los elementos de un array.

Operación quitarduplic (ent a: array [entero])

Modifica: a.

Calcula: quita los elementos repetidos de a. El límite inferior del array no varía, pero sí lo puede hacer el superior.



Ejemplo 2: concatenar dos cadenas.

Operación concat (ent a,b: cadena; sal c: cadena)

Calcula: la cadena de salida c es una nueva cadena que contiene los caracteres de a (en el mismo orden) seguidos de los caracteres de b (en el mismo orden).



Ejemplo 3: buscar un elemento en un array de enteros.

Operación buscar (ent a: array [entero]; x: entero;

sal i: entero)Requiere: que a esté ordenado de forma ascendente.Calcula: si x está en a, entonces i debe contener el valor del índice tal que a[i]=x. Si x no está en a, entonces i=sup+1, donde sup es el índice superior del array a.



Parametrización de tipo: una operación está definida independientemente del tipo de sus parámetros.

Ejemplo 4: ordenar los elementos de un array. Operación ordenar [t: tipo] (ent a: array [t]; sal array

[t])Requiere: - t debe tener la operación

Opertipo menorque (ent t,t; sal bool) - t debe estar totalmente ordenado.

Modifica: a.Calcula: ordena según el orden determinado por

menorque



Ejemplo 5: buscar un elemento en un array.

Operación buscar [t: tipo] (ent a: array [t]; x: t; sal entero)

Requiere: - t debe tener las operaciones

Opertipo igual (ent t,t; sal bool)

Opertipo menorque (ent t,t; sal bool)

- t debe estar totalmente ordenado.

Calcula: ...... buscando con la operación igual.


Notación

TAD <nombre_tipo> es <lista_operaciones>

Descripción

Descripción textual del tipo

Operaciones

Especificación informal de las operaciones de la lista

Fin <nombre_tipo>

2.2. Especificaciones informales: Abstracciones de datos.


Ejemplo 6: TAD conjunto de enteros.TAD Cjto_de_enteros es crear, insertar, suprimir, miembro,

tamaño, elegirDescripción Los Cjto_de_enteros son cjtos. matemáticos modificables, que almacenan valores enteros.Operaciones Operación crear (sal Cjto_de_enteros) Calcula: devuelve un conjunto de enteros vacío. Operación insertar (ent c: Cjto_de_enteros; x: entero) Modifica: c.

Calcula: añade x a los elementos de c; después de la inserción, el nuevo conjunto es un conjunto cpost, posterior a la inserción (cpost = c U {x}).



Ejemplo 6: TAD conjunto de enteros.Operación suprimir (ent c: Cjto_de_enteros; x: entero)

Requiere: que c no sea vacío.Modifica: c.

Calcula: suprime x de c (cpost = c - {x}).Operación miembro (ent c: Cjto_de_enteros; x: entero; sal bool)

Calcula: devuelve true si x está en c, y false si no.Operación tamaño (ent c: Cjto_de_enteros; sal entero)

Calcula: devuelve el cardinal del conjunto c.Operación elegir (ent c: Cjto_de_enteros; sal entero)

Requiere: que c no sea vacío.Calcula: devuelve un valor arbitrario de c.

Fin Cjto_de_enteros.



Ejemplo 7: TAD polinomio. TAD polinomio es crear, grado, coef, sumar, multiplicar, restar, menos,

igual Descripción polinomio son polinomios de coeficientes enteros no

modificables.Operaciones Operación crear (ent c,n: entero; sal polinomio) Requiere: n 0. Calcula: devuelve el polinomio cxn. Operación grado (ent p: polinomio; sal entero) Calcula: el entero que es el grado del polinomio. Operación coef (ent p: polinomio; n: entero; sal entero) Requiere: n 0.

Calcula: devuelve el coeficiente del término del polinomio p cuyo exponente sea n. Si n es mayor que el término de mayor grado o si no está, devuelve 0.



Ejemplo 7: TAD polinomio. Operación sumar (ent p,q: polinomio; sal polinomio) Calcula: devuelve un polinomio suma de p y q.

Operación multiplicar (ent p,q: polinomio; sal polinomio) Calcula: ...Operación restar (... Calcula: ...Operación menos (ent p: polinomio; sal polinomio) Calcula: devuelve z – p, donde z es el polinomio 0.Operación igual (ent p,q: polinomio; sal bool) Calcula: devuelve true si p y q tienen los mismos coeficientes para todos los términos del mismo grado, y, si no, devuelve false.Fin polinomio.



Ejemplo 8: conjuntos. TAD Cjto [t: tipo] es crear, insertar, suprimir, miembro,

tamaño, elegir.Requiere: t debe tener la operación

Opertipo igual (ent t,t; sal bool)Descripción

<descripción general del tipo>Operaciones

Operación crear (sal Cjto [t])Calcula: ...

...



Ejemplo 9: listas. TAD lista [t: tipo] es crear, construir, primero, resto, vacía, igual.

DescripciónSon secuencias inmutables no acotadas de elementos de tipo t.

Operaciones Operación crear (sal lista [t]) Calcula: devuelve una lista vacía. Operación construir (ent x: lista [t]; i: t; sal lista [t]) Calcula: devuelve una lista que contiene i como primer elemento, y los elementos de x como el resto. Operación primero (ent x: lista [t]; sal t); Requiere: que x sea no vacía. Calcula: devuelve el primer elemento de la lista.



• Ejemplo: Sobre el TAD Conjunto_de_enteros queremos añadir operaciones para calcular la suma, el producto, ...

Operación suma_conj (ent c: conj_enteros; sal entero)Calcula: devuelve la suma de los elementos de c.

....

Operación producto_conj (ent c: conj_enteros; sal entero)....

Operación varianza_conj (ent c: conj_enteros; sal real)....

2.2. Especificaciones informales: Abstracciones de iteradores.


• Es más adecuado tener una abstracción de la forma:

For cada elemento i del conjunto A

Do acción sobre i

• Abstracción de iteradores:

Una de las entradas puede ser la función que se aplica a los elementos:

Iterador <nombre>(ent <id>:<tipo>;...; sal <tipores>)

Requiere: ...

Modifica: ...

Calcula: ...

2.2. Especificaciones informales: Abstracciones de iteradores


• Ejemplo:

Iterador ParaTodoHacer[T:tipo] (ent C:conjunto; accion: operacion)

Requiere: accion es una operación que requiere parámetro de tipo T y no devuelve nada.

Calcula: recorre todos los elementos del conjunto C y realiza sobre ellos la accion.



• Se puede hacer a través de un TAD:

TipoIterador <nombre> es <lista_operaciones>)

Requiere: requisitos del iterador.

Descripción: del significado y uso del iterador.

Operaciones: especificación de cada operación de la lista



TipoIterador IteradorPreorden [T: tipo] es Iniciar, Actual, Avanzar, EsUltimo Descripción Los valores de tipo IteradorPreorden[T] son iteradores definidos

sobre árboles binarios de cualquier tipo T. Los elementos del árbol son devueltos en preorden. El iterador se debe inicializar con Iniciar.

Operaciones Operación Iniciar (ent A: ArbolBinario[T]; sal IteradorPreorden) Calcula Devuelve un iterador nuevo, colocado sobre la raíz de A. Operación Actual (ent iter: IteradorPreorden; sal T) Calcula Devuelve el elemento actual en la iteración. Operación Avanzar (ent iter: IteradorPreorden) Requiere EsUltimo(iter) debe ser falso. Modifica iter Calcula Avanza el iterador iter al siguiente elemento en preorden, dentro del

árbol binario sobre el que fue creado. Operación EsUltimo (ent iter: IteradorPreorden; sal booleano) Calcula Devuelve verdadero si y sólo si el elemento actual de la iteración es el

último.Fin IteradorPreorden.



• Las especificaciones en lenguaje natural son ambiguas e imprecisas.

• Especificaciones formales: definen un TAD o una operación de manera precisa, utilizando un lenguaje matemático.

• Ventajas de una especificación formal:– Prototipado. Las especificaciones formales pueden

llegar a ser ejecutables.– Corrección del programa. Verificación automática y

formal de que el programa funciona correctamente.– Reusabilidad. Posibilidad de usar la especificación

formal en distintos ámbitos.

2.3. Especificaciones formales.


NotaciónLa descripción formal constará de cuatro partes:• NOMBRE. Nombre genérico del TAD.• CONJUNTOS. Conjuntos de datos que

intervienen en la definición.• SINTAXIS. Signatura de las operaciones

definidas.– <nombre_operación> : <conj_dominio> <conj_resultado>

• SEMÁNTICA. Indica el significado de las operaciones.



• Los distintas notaciones formales difieren en la forma de definir la semántica:– Método axiomático o algebraico. Se establece

el significado de las operaciones a través de relaciones entre operaciones (axiomas). Significado implícito de las operaciones.

– Método constructivo u operacional. Se define cada operación por sí misma, independientemente de las otras. Significado explícito de las operaciones.



• Supongamos un TAD, T.• Tipos de operaciones

– Constructores. Conjunto mínimo de operaciones del TAD, a partir del cual se puede obtener cualquier valor del tipo T.

c1: T, c2: V T, c3: V1x...xVn T

– Modificación. A partir de un valor del tipo obtienen otro valor del tipo T, y no son constructores.

m1: T T, m2: TxV T, m3: TxV1x...xVn T

– Consulta. Devuelven un valor que no es del tipo T.

o1: T V, o2: TxV V’, o3: TxV1x...xVn Vn+1

2.3.1. Método axiomático.


• NOMBRE Booleano• CONJUNTOS B conjunto de valores

booleanos, U conjunto universal.• SINTAXIS

verdadero : B ; falso : B ; Not : B B ; And : B×B B ; Or : B×B B ; Si : B×B B ;

• SEMÁNTICA para todo b en B y u1 y u2 en U1. Not (verdadero)=falso2. Not (falso)=verdadero3. And (verdadero,b)=b4. ...

2.3.1. Método axiomático: ejemplo de TAD Booleano


NOMBRE natural CONJUNTOS N conjunto de naturales, B conjunto de valores booleanos SINTAXIS cero: N sucesor: N N escero: N B igual: N x N B suma: N x N N SEMANTICA m, n N 1. escero (cero) = true 2. escero (sucesor (n)) = false 3. igual (cero, n) = escero (n) 4. igual (sucesor (n), cero) = false 5. igual (sucesor (n), sucesor (m)) = igual (n, m) 6. suma (cero, n) = n 7. suma (sucesor (m), n) = sucesor (suma (m, n))

2.3.1. Método axiomático: TAD números naturales


• Una especificación es completa si de cualquier expresión se puede encontrar otra más sencilla, con operaciones de construcción.

• Una especificación es correcta si a partir de una expresión sólo se puede obtener un resultado final.

• ¿Cómo garantizar que una especificación es completa y correcta?

• Definir los axiomas suficientes para relacionar las operaciones de modificación y consulta con los constructores.

• No incluir axiomas que se puedan deducir de otros existentes.



NOMBRE pila (elemento) CONJUNTOS S conjunto de pilas, I conjunto de elementos, B

conjunto de valores booleanos SINTAXIS crearpila: S esvacíapila:S B sacar: S S cabeza: S I meter: I x S S

En el caso de cabeza: S I, ¿qué pasa si S es vacía? Se puede añadir un conjunto de mensajes en CONJUNTOS, de la forma:

M conjunto de mensajes {‘la pila está vacía’}

y variar en la parte de SINTAXIS la operación cabeza: cabeza: S I U M

2.3.1. Método axiomático: Especificación del TAD pila.


Para obtener la semántina relacionar las modificaciones y consultas con los constructores

SEMANTICA i I , s S1. esvacíapila (crearpila) = true2. esvacíapila (meter (i, s)) = false3. sacar (crearpila) = crearpila4. sacar (meter (i,s)) = s5. cabeza (crearpila) = ‘la pila está vacía’6. cabeza (meter (i, s)) = i Podemos hacer una pequeña modificación: supongamos que sacar, cuando se

aplica a la pila vacía, devuelve el mensaje ‘la pila está vacía’. Quedaría: sacar (crearpila) = ‘la pila está vacía’

En la sintaxis, sacar quedaría de la forma: sacar: S S U M ¿Qué debemos cambiar si queremos que cabeza también saque el elemento de

la pila?

2.3.1. Método axiomático: Especificación del TAD pila.


Para facilitar la escritura de la expresión del resultado en la parte semántica, se pueden emplear expresiones condicionales:SI <condición> <valor si cierto> | <valor si falso>

Ejemplo: TAD bolsa (colección de elementos, no ordenados, con repetición).

NOMBRE bolsa (elemento) CONJUNTOS S conjunto de bolsas, I conjunto de elementos, B

conjunto de valores booleanos, N naturales SINTAXIS bolsavacía: S , poner: S x I S , esvacía: S B , cuántos: S x I N SEMANTICA i, j I , s S cuántos (bolsavacía, i) = cero cuántos (poner (s, j), i) = SI j = i sucesor (cuántos (s, i)) | cuántos (s, i)

2.3.1. Método axiomático: Especificación del TAD bolsa.


• Ejecución de una especificación formal: aplicar sucesivamente las reglas de la semántica.

Reducción de la expresión Suma(sucesor(sucesor(cero)),sucesor(cero))

Suma (sucesor(sucesor(cero)), sucesor(cero)) = Axioma 7, con n= sucesor(cero), m= sucesor(cero)

sucesor (Suma (sucesor(cero), sucesor(cero))) = Axioma 7, con n= cero, m= sucesor(cero)]

sucesor(sucesor(Suma (cero, sucesor(cero)))) = Axioma 6, con n=sucesor(cero)

sucesor(sucesor(sucesor(cero)))



• Se diferencia del axiomático en la semántica. • Para cada operación, se establecen las

precondiciones y las postcondiciones.• Precondición: Relación que se debe cumplir con los

datos de entrada para que la operación sepueda aplicar.

• Postcondición: Relaciones que se cumplen después de ejecutar la operación. No debe incluir detalles de implementación.

NotaciónPara cada operación <nombre>:pre-<nombre> (<param_entrada>)::= <condición_lógica>post-<nombre> (<param_entrada>;<param_salida>)::=

<condición_lógica>

2.3.2. Método constructivo.


• Ejemplo: operación máximo, que tiene como entrada dos números reales y da como salida el mayor de los dos.máximo: R x R R (SINTAXIS)

pre-máximo (x, y) ::= true (SEMANTICA) post-máximo (x, y; r) ::= (r x) (r y) (r=x r=y)

• Ejemplo: máximo restringido, que sólo se aplica a enteros positivos.

max_restring: Z x Z Z pre-max_restring (x, y) ::= (x > 0) (y > 0) post-max_restring (x, y; r) ::= (r x) (r y) (r=x r=y)¿Qué sucedería si x o y no son mayores que 0? No se cumple la precondición no podemos asegurar que

se cumpla la postcondición.



• Ejemplo: máximo restringido, que sólo se aplica a enteros positivos.

Otra posibilidad: Definir un conjunto M (de mensajes de error) y cambiar la imagen. Modificar la sintaxis y la semántica:

max_restring: Z x Z Z U M

pre-max_restring (x, y) ::= true

post-max_restring (x, y; r) ::= if (x > 0) (y > 0)

then (r x) (r y) (r=x r=y)

else r = ‘fuera de rango’



• Programación por contrato (tomado de OO).• Contrato de una operación: si se cumplen unas

condiciones en los parámetros de entrada, entonces garantiza una obtención correcta del resultado.– La operación no trata todos los casos de error, sino que

hace uso de las precondiciones.– La responsabilidad de comprobar la condición de error

es del que usa la operación.– Si no se cumple la precondición se puede:

• No especificar nada.• Generar una excepción.• Incluir el tratamiento de errores en la especificación.



Algunas veces es necesario tener tipos subyacentes para especificar otros complejos. Ej: para especificar Pila[T] o Cola[T] el tipo subyacente puede ser Lista[T].

Ejemplo: TAD cola. Definiremos el TAD lista mediante el método axiomático, y luego lo usaremos para definir el TAD cola con el método constructivo.



NOMBRE lista (elemento) CONJUNTOS L conjunto de listas , I conjunto de elementos , B

booleanos , N naturales , M conjunto de mensajes {‘la lista está vacía’}

SINTAXIScrearlista: Lformarlista: I Lconcatenar: L x L Lúltimo: L I U Mcabecera: L Lprimero: L I U Mcola: L Llongitud: L Neslistavacía: L B



SEMANTICA i I a,b L 1. último (crearlista) = ‘la lista está vacía’2. último (formarlista (i)) = i3. último (concatenar (a, b)) = SI eslistavacía (b) último (a) | último (b)4. cabecera (crearlista) = crearlista5. cabecera (formarlista (i)) = crearlista6. cabecera (concatenar (a, b)) = SI eslistavacía (b) cabecera (a)

| concatenar (a, cabecera (b))7. primero (crearlista) = ‘la lista está vacía’8. primero (formarlista (i)) = i9. primero (concatenar (a, b)) = SI eslistavacía (a) primero (b) | primero (a)10. cola (crearlista) = crearlista11. cola (formarlista (i)) = crearlista12. cola (concatenar (a, b)) = SI eslistavacía (a) cola (b) | concatenar (cola (a), b)13. longitud (crearlista) = cero14. longitud (formarlista (i)) = sucesor (cero)15. longitud (concatenar (a, b)) = suma (longitud (a), longitud (b)) 16. eslistavacía (crearlista) = true17. eslistavacía (formarlista (i)) = false18. eslistavacía (concatenar (a, b)) = eslistavacía (a) AND eslistavacía(b)



Ejemplo: definición del tipo cola, con subyacente lista.NOMBRE cola (elemento) CONJUNTOS Q conjunto de colas, I conjunto de elementos, B booleanos SINTAXIS crearcola: Q, frente: Q I, supcola: Q Q, inscola: I x Q Q,

esvacíacola: Q B SEMANTICA iI; qQ; bB; rQ; pI; pQ pre-crearcola () ::= true post-crearcola (q) ::= q = crearlista pre-frente (q) ::= not eslistavacía (q) post-frente(q; p) ::= p = primero (q) pre-inscola (i, q) ::= true post-inscola (i, q; r) ::= r = concatenar (q, formarlista (i)) pre-supcola (q) ::= not eslistavacía (q) post-supcola (q; t) ::= t = cola (q) pre-esvacíacola (q) ::= true post-esvacíacola (q; b) ::= b = eslistavacía (q)



• La ejecución de especificaciones constructivas se puede simular. Si la precondición es cierta se puede dar por cierta la postcondición, si no lo es se produce un error.

• En C++ se puede incluir la función assert(condicion)

para comprobar que se cumple la pre o postcondición. Si es falsa se genera una excepción.

2.3. Métodos formales.

A.E.D. 1 Tema 2. Abstracciones y especificaciones. Tema 2. Abstracciones y Especificaciones. 2.1....

Documents

Transcript of A.E.D. 1 Tema 2. Abstracciones y especificaciones. Tema 2. Abstracciones y Especificaciones. 2.1....