Lección 10. Corrección de un algoritmowebdiis.unizar.es/asignaturas/PROG2/doc/grupo_412/transparencias/...predicados 2. Concepto de corrección de un algoritmo – ... omás débil

Programación 2

Lección 10. Corrección de un algoritmo

1

1. Estados de un algoritmo y satisfacción de predicados

2. Concepto de corrección de un algoritmo– Ejemplos

3. Axioma de la instrucción de asignación– Ejemplos

4. Axioma de la instrucción de devolución de valor

– Ejemplos

5. Axioma de la instrucción nula– Ejemplos

2

1. Estados de un algoritmo y predicados• Un algoritmo cambia de estado al ser ejecutado su código (pasa por una

sucesión de estados):[Estado inicial] E0 → E1 → E2 → → Ef‐1 → Ef [Estado final]

• El estado de un algoritmo viene definido por su punto de ejecución y porlos valores de sus datos.

// Pre: n ≥ 0// Post: factorial(n) = ([1,n]. )int factorial (const int n) {

int indice = 0, resultado = 1;while (indice != n) {

indice = indice + 1; resultado = indice * resultado;

}return resultado;

}3

• Un predicado se satisface para un estado E si, al ser evaluado, su valor escierto (true). En caso contrario, si su valor es falso (false), diremos queel predicado no se satisface para ese estado

• La precondición es un predicado que se formula para su estado inicial(sobre los datos de partida) y la postcondición es un predicado que seformula para su estado final (sobre los resultados)


// Pre: n ≥ 0int indice = 0, resultado = 1;while (indice != n) {


}return resultado;// Post: factorial(n) = ([1,n]. )

}4

• Podemos documentar un algoritmo con aserciones adicionales. Sonpredicados que debieran satisfacerse, si el algoritmo estuviera biendiseñado, para los estados del algoritmo alcanzados en los puntos delcódigo en los que se insertan.


// Pre: n ≥ 0int indice = 0, resultado = 1;// Aserción: resultado = ([1,indice]. )while (indice != n) {

// Aserción: resultado = ([1,indice]. )indice = indice + 1; resultado = indice * resultado;

}// Aserción: resultado = ([1,n]. )return resultado;// Post: factorial(n) = ([1,n]. )

} 5

Relaciones entre dos predicados P y Q:

• P es igual o más fuerte que Q si todo estado que satisface Ptambién satisface Q ( también puede afirmarse que Q es igualo más débil que P)• P Q

• P es equivalente a Q si todo estado que satisface P tambiénsatisface Q y viceversa• P Q [ P = Q ]

6

Estados quesatisfacen P

Estados quesatisfacen Q

Estados quesatisfacen P

Estados quesatisfacen Q

2. Concepto de corrección de un algoritmo

// P

A

// Q

La corrección del código A se plantea con relación a unaprecondición P y a una postcondición Q.

Diremos que el código A es correcto si para toda ejecución queparta de un estado [inicial] que satisfaga la precondición P,ésta concluye en un tiempo finito y el estado [final] alcanzadosatisface su postcondición Q

7

Concepto de corrección de un algoritmo// P

A

// Q


8

Esta definición es clave.Hay que saberla de MEMORIA

y, sobre todo, hay que COMPRENDERLA

¿Cuándo no es correcto un algoritmo?

// P

A

// Q


Por lo tanto, no será correcto en dos casos:1. Si se presenta algún caso tal que …2. Si se presenta algún caso tal que …

9

¿Cuándo no es correcto un algoritmo?

// P

A

// Q

Diremos que el código A es correcto si para toda ejecución que parta de unestado [inicial] que satisfaga la precondición P, ésta concluye en un tiempofinito y el estado [final] alcanzado satisface su postcondición Q

Por lo tanto, no será correcto en dos casos:

1. Si se presenta algún caso tal que la ejecución de A parta de un estadoque satisfaga su precondición P y no concluya (por un error en laejecución, un bucle infinito o una recursión infinita)

2. Si se presenta algún caso tal que la ejecución de A parta de un estadoque satisfaga su precondición P y concluya en un estado que nosatisfaga su postcondición Q

10

¿Es correcta esta secuencia de asignaciones (x e y son datos de tipo T)?

// x = M y = N

T aux = x; x = y; y = aux;

// x = N y = M


// x = M y = N

x = x + y; y = x – y ; x = x ‐ y;

// x = N y = M


// x = M y = N

x = y; y = x;

// x = N y = M

11


// x = M y = N


// x = N y = M


// x = M y = N

x = x + y; y = x ‐ y; x = x ‐ y;

// x = N y = M


// x = M y = N

x = y; y = x;

// x = N y = M

12


// x = M y = N


// x = N y = M


// x = M y = N

x = x + y; y = x ‐ y; x = x ‐ y;

// x = N y = M


// x = M y = N

x = y; y = x;

// x = N y = M

13


// x = M y = N


// x = N y = M


// x = M y = N

x = x + y; y = x ‐ y; x = x ‐ y;

// x = N y = M


// x = M y = N

x = y; y = x;

// x = N y = M

14




// x = M y = N


// falso


// cierto

x = y; y = x;

// x = N y = M

15




// x = M y = N


// falso


// cierto

x = y; y = x;

// x = N y = M

16

?




// x = M y = N


// falso


// cierto

x = y; y = x;

// x = N y = M

17

?




// x = M y = N


// falso


// cierto

x = y; y = x;

// x = N y = M

18

?

¿Es correcta esta instrucción de asignación?

// falso

x = y + 1;

// x = y


// x > 0

x = x / y;

// cierto


// falso

x = x / y;

// cierto

19


// falso

x = y + 1;

// x = y


// x > 0

x = x / y;

// cierto


// falso

x = x / y;

// cierto

20


// falso

x = y + 1;

// x = y


// x > 0

x = x / y;

// cierto


// falso

x = x / y;

// cierto

21


// falso

x = y + 1;

// x = y


// x > 0

x = x / y;

// cierto


// falso

x = x / y;

// cierto

22

3. Axioma de la instrucción de asignación

Esta instrucción de asignación es correcta , por definición :

// Dom(v = E)

v = Exp;

// Q

Dom(v = Exp): condiciones que han de satisfacerse para que pueda serevaluada la expresión v = Exp sin errores (se habla decondiciones de dominio).

: predicado resultante de sustituir en el predicado Q cada ocurrencia

de la variable v por la expresión Exp.23

¿Un predicado P que haga que la instrucción de asignación sea correcta?

// P

x = x + 1;

// x + y > x * z

24


// P

x = x + 1;

// x + y > x * z

// Dom(x = x+1) (x + 1) + y > (x + 1) * z

x = x + 1;

// x + y > x * z

25


// P

x = x + 1;

// x + y > x * z

// Dom(x = x + 1) (x + 1) + y > (x + 1) * z

x = x + 1;

// x + y > x * z

// cierto (x + 1) + y > (x + 1) * z

x = x + 1;

// x + y > x * z

26


// P

x = x + 1;

// x + y > x * z

// cierto (x + 1) + y > (x + 1) * z

x = x + 1;

// x + y > x * z

// (x + 1) + y > (x + 1) * z

x = x + 1;

// x + y > x * z

27


// P

v[j] = v[i] + v[i‐1] / v[i+1];

// v[j] > 0

28


// P

v[j] = v[i] + v[i‐1] / v[i+1];

// v[j] > 0

// Dom(v[j] = v[i] + v[i‐1]/v[i+1])

// v[i] + v[i‐1] / v[i+1] > 0

v[j] = v[i] + v[i‐1] / v[i+1];

// v[j] > 0

29


// P

v[j] = v[i] + v[i‐1] / v[i+1];

// v[j] > 0

// Dom(v[j] = v[i] + v[i‐1] / v[i+1])

// v[i] + v[i‐1] / v[i+1] > 0

v[j] = v[i] + v[i‐1] / v[i+1];

// v[j] > 0

// j 0 j < #v – 1 i 1 i < #v – 1

// v[i+1] 0 v[i] + v[i‐1] / v[i+1] > 0

v[j] = v[i] + v[i‐1] / v[i+1];

// v[j] > 030

4. Axioma de la instrucción de devolución de valor

tipoValorDevuelto nombreFunción (lista_de_parámetros)

Esta instrucción de devolución de valor es correcta , por definición:

// Dom(Exp) Q ó á

return Exp;

// Q

Dom(Exp): condiciones que han de satisfacerse para que pueda ser evaluadala expresión Exp sin errores (sus condiciones de dominio).

Q ó á : predicado resultante de sustituir en el

predicado cada ocurrencia de la invocación por la expresión Exp.31




}// Preturn resultado;// Post: factorial(n) = ([1,n]. )

}

¿Un predicado P que haga que la última instrucción sea correcta?

32

// Pre: n ≥ 0// Post: factorial(n) = ([1,n]. )int factorial (int n) {



}// Dom(resultado) resultado = ([1,n]. )return resultado;// Post: factorial(n) = ([1,n]. )

}

Ese predicado garantiza que la última instrucción es correcta33




}// cierto resultado = ([1,n]. )return resultado;// Post: factorial(n) = ([1,n]. )

}

Ese predicado garantiza que la última instrucción es correcta

34




}// resultado = ([1,n]. )return resultado;// Post: factorial(n) = ([1,n]. )

}

Ese predicado garantiza que la última instrucción es correcta35

5. Axioma de la instrucción nulaEsta instrucción nula es correcta, por definición :

// P

;

// P

36

¿Un predicado P que haga que esta instrucción nula sea correcta?

// P

;

// x + y > x * z


// P

;

// v[i] > 0

37


// x + y > x * z

;

// x + y > x * z


// v[i] > 0

;

// v[i] > 0

38

Documents

Lección 10. Corrección de un algoritmowebdiis.unizar.es/asignaturas/PROG2/doc/grupo_412/transparencias/...predicados 2. Concepto de corrección de un algoritmo – ... omás débil