Programación imperativa. Algoritmos y Estructuras de Datos I. Ciclos

Transcripción

1 Programación imperativa Algoritmos y Estructuras de Datos I Segundo cuatrimestre de 2014 Departamento de Computación - FCEyN - UBA Programación imperativa - clase 6 Ciclos y arreglos Entidad fundamental: variables Corresponden a posiciones de memoria (RAM). Cambian expĺıcitamente de valor a lo largo de la ejecución de un programa. Tres instrucciones: asignación (y llamadas a funciones), condicional, ciclo Un programa es una lista de instrucciones, que se ejecutan una tras otra. La semántica de un programa se define mediante la composición de la semántica de las instrucciones por transformación de estados. 1 2 Programación imperativa Ciclos Aunque muchos lenguajes imperativos permiten implementar funciones recursivas, el mecanismo fundamental de cómputo no es la recursión. cuerpo del ciclo; B: expresión booleana del lenguaje de programación. Se la llama guarda. {cuerpo de ciclo: es un bloque de instrucciones entre llaves. Se repite mientras valga la guarda B, cero o más veces. La ejecución del ciclo termina si y solo si el ciclo se repite una cantidad finita de veces. Esto ocurre si y solo si la guarda B llega a ser falsa. Si el ciclo termina, el estado resultante es el estado posterior a la última instrucción del cuerpo del ciclo. 3 4

2 Ejemplo de un ciclo Correctitud de un ciclo respecto de una especificación problema fact(x : Int) = r : Int{ requiere x 0 asegura r == [1..x] En funcional: fact :: Int -> Int fact 0 = 1 fact i i>0 = i * (fact (i-1)) En imperativo: int fact (int x) { int f = 1; int i = 1; while (i x) { f = f * i; i = i + 1; return f; 5 Introducimos en el lenguaje de especificación P C : precondición del ciclo Q C : postcondición del ciclo B: guarda donde B corresponde a la guarda B del lenguaje de programación. int g(int x) {... // estado antesdelciclo // vale P C cuerpo del ciclo (una o más instrucciones); // estado despuesdelciclo // vale Q C... 6 Correctitud de un ciclo Invariante P C : precondición del ciclo, Q C : postcondición del ciclo, B: guarda I: invariante int g (int x) {... // estado antesdelciclo // vale P C // implica I // estado antes // vale B I cuerpo del ciclo (una o más instrucciones) // estado despues // implica I // vale I B; implica Q C... 7 Expresión booleana del lenguaje de especificación que se mantiene verdadera en los estados antes, durante y después de la ejecución de un ciclo. es análogo a la hipótesis inductiva que usamos para demostrar la correctitud de un programa recursivo en programación funcional. conviene darlo al escribir el ciclo porque expresa la idea del ciclo. no hay forma algorítmica de encontrarlo 8

3 Un ejemplo problema sumat(x : Int) = r : Int{ requiere x 0 asegura r == [0..x] En funcional: sumat :: Int -> Int sumat 0 = 0 sumat i = i + (sumat (i-1)) En imperativo: int sumat (int x) { int s = 0, i =x; while (i 0) { 9 Ejemplo sumat(int x) int sumat (int x) { int s = 0, i = x; while (i > 0) { // estado a // estado b Estados para x == 4 s@a i@a s@b i@b (i@a..x] i@a (i@b..x] i@b En estado a y b se cumple 0 i x y s == (i..x] (pero no en el medio) Cuando i == 0, la ejecución del ciclo termina. 10 Ejemplo sumat(int x) Transformación de estados dentro del ciclo int sumat (int x) { int s = 0; i = x; //vale P C : s == 0 i == x while (i > 0) { //estado e2 //estado e3 //vale Q C : i == 0 s == (0..x] //vale result == [0..x] La x no cambia porque es de entrada y no aparece en modifica ni en local. //vale B: i >0 //vale I : 0 i x s == (i..x] //estado e2 //vale i = i@e1 s == s@e1 + i@e1 //estado e3 //vale i == i@e2 1 s == s@e2 //implica i == i@e1 1 s == s@e1 + i@e1 porque i@e2 == i@e1 y s@e2 == s@e1 + i@e1. //implica 0 i x porque 0 < i@e1 x y i@e3 == i@e1 1 //implica s == (i..x] porque s@e1 == (i@e1..x] y s@e3 == s@e2 == s@e1 + i@e1 == (i@e1..x] + i@e1 == (i@e1 1..x] == (i@e3..x] 11 12

4 Terminación y correctitud de un ciclo respecto de una especificación Cómo demostramos que el ciclo termina? //vale P C ; //invariante I ; cuerpo //vale Q C ; Un ciclo termina si después de una cantidad finita de iteraciones se cumple la negación de la guarda. Un ciclo es correcto respecto a la especificación si comenzando su ejecución en un estado que cumple P C el ciclo termina en un estado que cumple Q C. Acotamos superiormente la cantidad de iteraciones restantes del ciclo mediante una expresión variante (v) Es una expresión del lenguaje de especificación, de tipo Int definida a partir de las variables del programa debe decrecer estrictamente en cada iteración //estado e; //vale B I ; cuerpo //vale v < v@e; Damos una cota (c) (valor entero fijo, por ejemplo 0 o 8) tal que si es alcanzado por la expresión variante, está garantizado que la ejecución alcanza un estado donde vale la negación de la guarda, y por lo tanto sale del ciclo Ejemplo de expresión variante Ejemplo de demostración de expresión variante decreciente. int sumat (int x) { int s = 0; i = x; //vale P C : s == 0 i == x while (i > 0) { //vale Q C : i == 0 s == (0..x] //vale result == [0..x] La expresión variante es un indicador de la distancia a la terminación del ciclo. //variante v : i, cota 0 Recordemos el programa sumat y la transformación de estados //variante v : i //vale B I //implica 0 < i x s == (i0..x] //estado e2 //vale i s == s@e1 + e@1 //estado e3 //vale i == i@e2 1 s == s@e2 Debemos ver que la expresión variante v : i es decreciente. Es decir, debemos ver que v@e1 > v@e3. Pero esto es inmediato, porque v@e1 == i@e1 y v@e3 == i@3 == i@e2 1 == i@e

5 Teorema de terminación Observaciones sobre terminación Sea I el invariante de un ciclo con guarda B, v una expresión variante v (expresión entera decreciente) y c una cota tal que (I v c) B. Entonces el ciclo termina. Demostración. Sea v j el valor que toma v en el estado que resulta de ejecutar el cuerpo del ciclo por j-ésima vez. Dado que v es de tipo Int, para todo j, v j Int. Como v es estrictamente decreciente, v 1 > v 2 > v 3 >..., existe un k tal que v k c. Dado que (I v c) B, en el estado alcanzado luego de k iteraciones vale B. Por lo tanto el ciclo termina. Qué pasaría si v fuese de tipo Float? Funcionaría esta demostración? Sea el siguiente programa: int dec1(int x) { while (x > 0) x = x 1; return x; Supongamos P c : x 0. I : x 0 v = x es estrictamente decreciente, cota c = 0. Dado que B : x > 0, se cumple v c B y por simple cálculo proposicional, (I v c) B. Es decir, no fue necesario usar el invariante I Observaciones sobre terminación Expresión variante y cota int dec2(int x) { while (x!= 0) x = x 1; return x; Supongamos P c : x 0 I : x 0 v = x, cota c = 0. Dado que B : not(x == 0), (I v c) B Notemos que en este caso sí necesitamos usar I ya que x 0 x == 0 pero (x 0 x 0) x == 0. Sea v una función variante y sea c su cota asociada. v = v c es una función variante con cota asociada 0. Sin pérdida de generalidad, podemos suponer siempre una función variante y cota asociada 0. v es estrictamente decreciente en las sucesivas iteraciones del ciclo. En cada iteración decrece en 1 o más unidades. Por lo tanto el valor de la expresión variante no necesariamente mide la cantidad de iteraciones (restantes) de la ejecución del ciclo

6 Teorema de correctitud de un ciclo Teorema del Invariante Sea P C, Q C, I, B, v la especificación de un ciclo que termina. Si se cumplen las relaciones de fuerza P C I y (I B) Q C entonces el ciclo es correcto con respecto a su especificación. Demostración. Debemos ver que para variables que satisfagan P C, el estado alcanzado cuando el ciclo termina satisface Q C. //vale P C ; //vale I B; cuerpo //vale I ; //estado e2 //vale Q C ; Supongamos que las variables en el estado e1 satisfacen P C como P C I, entonces en el estado e1 se cumple I. Supongamos que el ciclo ejecuta 0 o más veces. Por definición de invariante en cada iteración, el invariante se restablece. Por hipótesis, el ciclo termina y en el estado e2 vale B. Además, en el estado e2 vale I. Como (I B) Q C entonces en el estado e2 vale Q C. 21 Sea cuerpo un ciclo con guarda B, precondición P C y poscondición Q C. Sea I un predicado booleano, v una expresión variante, c una cota, y sean los estados e1 y e2 así: cuerpo //estado e2 Si valen: 1. P C I 2. (I B) Q C 3. el invariante se preserva en la ejecución del cuerpo, i.e. si I B vale en el estado e1 entonces I vale en el estado e2 4. v es decreciente, i.e. v@e1 > v@e2 5. (I v c) B entonces para cualquier valor de las variables del programa que haga verdadera P C, el ciclo termina y hace verdadera Q C, es decir, el ciclo es correcto para su especificación (P C, Q C ). Demostración. Inmediata del Teorema de Terminación (p. 17) y el Teorema de Correctitud (p. 21). 22 Cuales de los 5 puntos entran en el primer parcial? Retomamos ejemplo sumat Teoema del Invariante. Sea cuerpo un ciclo con guarda B, precondición P C y poscondición Q C. Sea I un predicado booleano, v una expresión variante, c una cota. Si valen: 1. P C I problema sumat(x : Int) = r : Int{ requiere P : x 0 asegura r == [0..x] 2. (I B) Q C 3. el invariante se preserva en la ejecución del cuerpo, i.e. si I B vale en el estado e1 entonces I vale en el estado e2 4. v es decreciente, i.e. v@e1 > v@e2 5. (I v c) B entonces para cualquier valor de las variables del programa que haga verdadera P C, el ciclo termina y hace verdadera Q C, es decir, el ciclo es correcto para su especificación (P C, Q C ). 1. P C I //vale P C : s == 0 i == x Supongamos que vale P C y veamos que vale I 1. i == x implica i x. 2. x 0 implica i s == 0 y i == x implica (i..x] == (x..x] == 0 == s. Los puntos 1,2 y 5 se demuestran usando lógica proposicional exclusivamente. Por lo tanto, (i == x s == 0) (0 i x s == (i..x]). Los puntos 3 y 4 quedan para después del primer parcial

7 Retomamos ejemplo sumat Retomamos ejemplo sumat 2. (I B) Q C // invariante I : 0 i x s == (i..x] // B : (i > 0) //vale Q C : i == 0 s == (0..x] Supongamos que vale I B y veamos que vale cada parte de Q C. Por I sabemos que 0 i. Por B sabemos i 0. Entonces, i == 0. Por I sabemos s == (i..x], y recién mostramos que i == 0, luego s == (0..x]. 5. (I v c) B //v c : i 0 // (B) : (i > 0) Supongamos que vale I (v c). Debemos ver que vale B. Esto es inmediato ya que (v c) == i 0 == B Arreglos Arreglos versus listas Secuencias de una cantidad fija de variables del mismo tipo. Se declaran con un nombre, un tamaño y un tipo. Ejemplo: int a[10]; // arreglo de 10 elementos enteros int a[]={0,1,2,3,4,5,6,7,8,9; //Inicializado Nos referimos a los elementos a través del nombre del arreglo y un índice, entre corchetes, que va de 0 a la dimensión menos uno: a[0], a[1],..., a[9] //acceso aleatorio Una referencia a una posición fuera del rango (usualmente) da error (en tiempo de ejecución). El tamaño y el tipo de un arreglo se mantienen invariantes a lo largo de la ejecución. Ambos son secuencias de elementos de un tipo dado. En el lenguaje de especificación tratamos a ambos con listas por comprensión. Longitud Los arreglos tienen longitud fija; las listas, no. Acceso Los elementos de un arreglo se acceden de manera directa, e independiente de los demás. a[i] accede al elemento en posición i-ésima del arreglo. Tiene dirección de memoria propia, y por lo tanto se le puede asignar un valor. Los elementos de una lista se acceden secuencialmente, empezando por la cabeza. Para acceder al i-ésimo elemento de una lista, hay que obtener i veces la cola y luego la cabeza

8 Arreglos en C++ Leyendo un arreglo Los arreglos en C++ son referencias. problema sumarray(a : [Int], tam : Int) = res : Int{ requiere P: tam == a ; asegura Q: res == a[0.. a ); No hay forma de averiguar su tamaño una vez que fueron creados; el programa tiene que encargarse de almacenarlo de alguna forma. Al ser pasados como argumentos, en la declaración de un parámetro no se indica su tamaño. Cuando se usan como argumentos de funciones en C y C++, pasan automáticamente como referencia ( no por copia!). 29 int sumarray(int a[], int tam){ int j = 0; int s = 0; // Pc: j == 0 s == a[0..j) while (j <tam) { // invariante 0 j tam s == a[0..j) // variante tam j; s = s + a[j]; j++; // Q c : s == a[0.. a ) // vale Q: res == a[0.. a ); 30 Inicialización de arreglos Modificando un arreglo problema init (a : [Int], x : Int, n : Int){ requiere n == a n > 0; modifica a; asegura todos([a[j] == x, j [0..n)]); asegura todos([a[j] == x, j [0..n)]); void init (int a[], int x, int n) { int i = 0; // vale P c : i == 0 while (i < n) { a[i]=x; i = i + 1; // invariante I: 0 i n todos([a[j] == x, j [0..i)]) // variantev : n i // vale Q c : i == n todos([a[j] == x, j [0..i)]) problema ceroporuno(a : [Int], tam : Int){ requiere tam == a ; modifica a; asegura a == [if i == 0 then 1 else i i pre(a)[0..tam)]; void ceroporuno(int a[], int tam) { int j = 0; // vale P c : j == 0 while (j < tam) { // invariante a[0..j) == [if i == 0 then 1 else i i pre(a)[0..j)]; // 0 j tam a[j..tam) == pre(a)[j..tam) // variante tam j; if (a[j] == 0) a[j] = 1; j++; 31 32