School of Informatics, University of Edinburgh

Transcription

1 CS1Bh Solution Sheet 3 Debugging and Logic This is a solution set for CS1Bh Question Sheet 3. You should only consult these solutions after attempting the exercises. Notice that the solutions are samples alternative answers may be possible. 1. Consider the following Java class, StringConcat. The intention of this class is to concatenate the command line arguments and to print them out. However, the implementation of the main method in the class contains a bug. Use the Java debugger to single-step through the program and find the bug. 1 class StringConcat { 2 public static void main (String[] args) { 3 String s = ""; 4 for (int i = 0 ; i < args.length ; i++) { 5 s.concat(args[i]); 6 7 System.out.println(s); 8 9 NOTE: The original version of this question sheet contained a bug, which, in turn induced an easily found bug in the StringConcat.java. This bug is corrected in the program shown above. The solution below refers to the corrected version and the remaining, less easily found, bug. Here is a trace of the Java debugger at work on this example, [scar]stg: jdb StringConcat test1 test2 test3 Initializing jdb... > stop at StringConcat:5 Deferring breakpoint StringConcat:5. It will be set after the class is loaded. > stop at StringConcat:7 Deferring breakpoint StringConcat:7. It will be set after the class is loaded. > run run StringConcat test1 test2 test3 > 1

2 VM Started: Set deferred breakpoint StringConcat:7 Set deferred breakpoint StringConcat:5 Breakpoint hit: thread="main", StringConcat.main(), line=5, bci=8 5 s.concat(args[i]); main[1] locals Method arguments: args = instance of java.lang.string[3] (id=194) Local variables: s = "" i = 0 main[1] cont > Breakpoint hit: thread="main", StringConcat.main(), line=5, bci=8 5 s.concat(args[i]); main[1] locals Method arguments: args = instance of java.lang.string[3] (id=194) Local variables: s = "" i = 1 main[1] cont > Breakpoint hit: thread="main", StringConcat.main(), line=5, bci=8 5 s.concat(args[i]); main[1] locals Method arguments: args = instance of java.lang.string[3] (id=194) Local variables: s = "" i = 2 main[1] cont > Breakpoint hit: thread="main", StringConcat.main(), line=7, bci=25 7 System.out.println(s); main[1] locals Method arguments: args = instance of java.lang.string[3] (id=194) Local variables: s = "" i = 3 main[1] cont > The application exited The bug is that the programmer has misunderstood that the concat() method returns a string 2

3 as its result, rather than updating it in-place. The fix is to replace line 5 by s = s.concat(args[0]); 2. In this example we are attempting to produce a simple program to count the number of characters in a text file. For this we need to use classes from the java.io package, the FileInputStream class and the DataInputStream class. As we know, any file input or output operations can raise Java exceptions. Because of this we enclose the readchar() method call inside a try block and we handle the problems of not finding the file, reaching the end of the file and other input errors in the expected way (see lines 13 to 19 of the following program). 3

4 1 import java.io.*; 2 class CountingCharacters { 3 public static void main (String[] args) { 4 int count = 0; 5 try { 6 FileInputStream f = new FileInputStream(args[0]); 7 DataInputStream d = new DataInputStream(f); 8 char c; 9 while (true) { 10 c = d.readchar(); 11 count++; catch (FileNotFoundException e) { 14 System.out.println("Could not find file "+args[0]); 15 catch (EOFException e) { 16 System.out.println("Character count: " + count); 17 catch (IOException e) { 18 e.printstacktrace(); The program which we have seems very simple, and it is hard to imagine that it could contain any errors. The name of the file to be read is passed into the program as the first entry in the array of command line arguments (args[0]). We open this as a FileInputStream and construct a DataInputStream on top (where previously in CS1Ah Lecture Note 29 we had seen an ObjectInputStream). We read characters from the file as seen on line 10. We count each character which we read on line 11. We repeat this until there are no characters left and then the EOFException is caught and the count of the number of characters is printed out on line 16. However, when we first use this program on a sample input file such as this: abcdefghijklmnopqrstuvwxyz the program prints the following message: Character count: 13 This is certainly not what we had expected. The input file contains 26 characters, not 13, so how has the program gone wrong? Use the Java debugger to find the bug. As usual, we single-step through the code inspecting the values of local variables. [scar]stg: jdb CountingCharacters inputfile Initializing jdb... > stop at CountingCharacters:10 Deferring breakpoint CountingCharacters:10. It will be set after the class is loaded. 4

5 > run run CountingCharacters inputfile > VM Started: Set deferred breakpoint CountingCharacters:10 Breakpoint hit: thread="main", CountingCharacters.main(), line=10, bci=25 10 c = d.readchar(); main[1] step main[1] Step completed: thread="main", CountingCharacters.main(), line=11, bci=31 11 count++; main[1] print c c =? At every stage we find that the character variable c prints as?. This seems to point the way to the diagnosis of the source of the error. For further clarification we would need to revise Java s idea of a character. Java reserves sixteen bits for a character (called a UNICODE character) whereas most programming languages only use eight (called an ASCII character). Thus each pair of eight-bit ASCII characters in the file is being interpreted (in this case incorrectly) as a single sixteen-bit UNICODE character. To repair this problem we need to read the characters as bytes and cast them to a character. We replace line 10 above with the following line to repair the problem. c = (char) d.readbyte(); With this correction in place the program counts characters correctly. 5

6 3. a) Use semantic trees to check whether each of the following formulas is a tautology. If it is not a tautology, describe a counter example. i. ((P Q) P ) P This and other solutions produced by choosing topmost signed formula to discharge in the event of a choice, unless otherwise stated. f: ((P Q) P ) P t: (P Q) P Q t: P t: P f: Q A tautology. ii. P Q P Q t: P Q Q P Q Q Q t: P t: Q t: P Q f: Q t: P t: Q t: P t: Q f: Q 6

7 Counter-examples from remaining open paths are {P f, Q t and {P t, Q f. iii. P (Q R) (P Q) (P R) (Q R) (P Q) (P R) t: P (Q R) f: (P Q) (P R) t: P t: Q R Q t: Q f: Q R t: R f: Q f: R A tautology. b) Use semantic trees to check whether each of the following formulas is satisfiable or a contradiction. If it is satisfiable, give a satisfying assignment. i. P P t: P P t: P t: P 7

8 A contradiction. ii. (P Q) P Q Q t: P f: Q t: (P Q) P Q t: P Q t: P t: Q Is satisfiable. Satisfying assignments include {P t, and {Q t. iii. (P Q) (Q R) (P R) Here we vary the order of discharging nodes to keep the tree size down. We also split the top-level conjunction in a single step. t: (P Q) (Q R) (P R) t: P Q t: Q R t: (P R) R t: P f: R t: Q f: Q t: R A contradiction. 4. Here are some exercises in reasoning by using chains of logical equivalences. See Lecture Note 18 for background and a list of equivalence rules you can use. In your solutions, give a few words by each step to explain why that step is justified. 8

9 a) P Q R P Q R P Q R P ( Q R) characterisation ( P Q) R associativity (P Q) R de Morgans law P Q R characterisation b) P (Q P ) t P (Q P ) P ( Q P ) characterisation (P P ) Q assoc. and comm. t Q Excluded middle t Excluded Middle is the name given to the rule (P P ) t. It was included in CS1Ah Lecture Note 18, though its name was omitted. c) P ( P Q) P Q (Use only rules 1-18). P ( P Q) (P P ) (P Q) dist. over f (P Q) P Q d) (P Q) ( P R) (P Q) ( P R) (P Q) ( P R) ( P Q) (P R) characterisati ( P P ) ( P R) (Q P ) (Q R) dist. over (P Q) ( P R) ( P P ) (Q R) comm. (P Q) ( P R) (Q R) (P Q) ( P R) ((P P ) Q R) identity for (P Q) ( P R) (P Q R) ( P Q R) dist over (P Q) ( P R) e) (i j j k) i > j i j j k (State and use an extra rule relating < and ) Using extra rule that a > b (a b), we have (i j j k) i > j (i j j k) (i j) extra rule (i j (i j)) (j k (i j)) dist. over t (j k (i j)) excluded middle law j k (i j) t identity for i j j k comm. + characterisation 9

10 5. a) Put the following formulas in disjunctive normal form using chains of equivalence steps. A general procedure for applying equivalence rules to put propositions in DNF is: i. Eliminate occurrences of and using their characterisations in terms of, and. ii. Push all occurrences of inwards and cancel double occurrences. All s should now only surround variables. iii. Repeatedly distribute s over s (push s under the s). i. (P Q) (Q R) (P Q) (Q R) ( P Q) ( Q R) (( P Q) Q) (( P Q) R) ( P Q) (Q Q) ( P R) (Q R) ( P Q) ( P R) (Q R) Here the expression was already in DNF at the penultimate step, but then we applied some simplification. ii. (P 1 Q 1 ) (P 2 Q 2 ) (P 3 Q 3 ) One DNF form for this expression is (P 1 P 2 P 3 ) (P 1 P 2 Q 3 ) (P 1 Q 2 P 3 ) (P 1 Q 2 Q 3 ) (Q 1 P 2 P 3 ) (Q 1 P 2 Q 3 ) (Q 1 Q 2 P 3 ) (Q 1 Q 2 Q 3 ) If we had n conjuncts instead of 3, we would have 2 n conjuncts in the DNF form. If we care about keeping the size of expressions down, putting them in DNF (or CNF) is not always a good idea! b) Put the following formulas in conjunctive normal form: The general procedure is the same as for DNF, except in step 3, one instead repeatedly distributes s over s. i. (P Q) (Q R) (P Q) (Q R) ( P Q) ( Q R) 10

11 ii. P Q P Q (P Q P Q) ((P Q (P Q)) ( (P Q) (P Q)) (P Q) (P Q) (( P Q) ( P Q)) (P Q) ( P Q) Here we have additionally used instances of the idempotence rules A A A and A A A to simplify expressions, though we still would have got a DNF expression without these rules. 6. Consider the following truthtable for a 3 argument propositional operator C. P Q R C(P, Q, R) f f f f t f f f f t f f t t f t f f t f t f t t f t t t t t t t Write down a formula for C in a. DNF, b. CNF. Hint: for DNF, write one disjunct for each variable truth assignment making the operator true. For CNF, write one conjunct for each variable truth assignment making the operator false. A DNF form is A CNF form is (P Q R) (P Q R) ( P Q R) (P Q R) (P Q R) ( P Q R) (P Q R) (P Q R) 7. Consider writing down propositions in n propositional variables. What s the largest set S of such propositions such that for no two different propositions P, Q in S, we have that P Q is a tautology? Hint: this is related to, but much bigger than, the number of valuations you have to check to see if P is a tautology. P Q is a tautology just when P and Q have the same truth tables, so the number of distinct propositions is the same as the number of distinct truth tables. A truth table for a proposition in n variables has 2 n rows, one row for each valuation of the variables. For each row, there are 2 possibilities for the truth value of the proposition, so there are overall 2 2n possible truth tables. Hence the largest set S has size 2 2n. 11

12 8. Lecture Note 19 considered a class A with an integer array field x and a method findmin() for finding the minimum value stored in x: class A { private int[] x; public int findmin() { int min = x[0]; for (int i = 1; i!= x.length ; i++) { if (x[i] < min) min = x[i]; return min; One property not checked by the assertions and loop invariant discussed in the note is that the min value returned actually occurs in the array x. a) Using ESC/Java-like syntax, annotate the the class definition with an ensures postcondition, assert statements and a loop invariant appropriate for checking this property. Hint: you will need to use a \exists quantifier. A solution, very similar to that from the lecture note, is: class A { private int[] x; //* requires x!= null && x.length!= 0; //* ensures //* (\exists int n; 0 <= n & n < x.length & \result == x[n]); public int findmin() { int min = x[0]; //* assert min == x[0]; //* loop_invariant //* (\exists int n; 0 <= n & n < i & min == x[n]); for (int i = 1; i!= x.length ; i++) { if (x[i] < min) min = x[i]; //* assert //* (\exists int n; 0 <= n & n < x.length & min == x[n]); return min; 12

13 b) Using the Java 1.4 assertion facility, code an appropriate post-condition check for this property. Use an auxiliary method as shown in the note. A solution is: class A { private int[] x; public int findmin() { assert x!= null && x.length!= 0 : "A.findMin: precondition" ; int min = x[0]; for (int i = 1; i!= x.length ; i++) { if (x[i] < min) min = x[i]; assert checkpostcondition(min) : "A.findMin: postcondition" ; return min; private boolean checkpostcondition(int min) { boolean val = false; for (int i = 0; i!= x.length; i++) { val = val (x[i] == min); return val; 9. Using ESC/Java-like syntax, complete the the requires (precondition), ensures (postcondition) and loop invariant assertions for the following Java method which evaluates the integer value of a boolean array arr: //@ requires... //@ ensures \result =... static boolean intval(int i; int[] arr) { int val = 0; //@ loop_invariant val =... for (int j = 0; j!= arr.length; j++) { if (arr[j]) val = val + intpow(2,j); return val; Assume that a method static int intpow(int a, int b) {... 13

14 for computing a b is defined elsewhere in the same class. Use the syntax (\sum int k; i<=k & k<j; e) to express the mathematical sum j 1 e. k=i You might also want to make use of conditional expressions in Java which have form b? e 1 : e 2. If b evaluates to true, this expression evaluates to e 1. Otherwise it evaluates to e 2. A solution is: //@ requires arr!= null; //@ ensures \result = //@ (\sum int k; 0<=k & k<arr.length; arr[k]? intpow(2,k) : 0); static boolean intval(int i; int[] arr) { int val = 0; //@ loop_invariant //@ val = (\sum int k; 0<=k & k<j; arr[k]? intpow(2,k) : 0); for (int j = 0; j!= arr.length; j++) { if (arr[j]) val = val + intpow(2,j); return val; 10. In the spirit of the overview in Lecture Note 19 of the assertion languages of JML and ESC/Java, write requires (precondition) and ensures (postcondition) pragmas for the method public void add(int index, Object element); found in the LinkedList Java collection class ( see 4.1/docs/api/java/util/LinkedList). Your precondition should check that the collection reference (refer to it using this) is non null and that the index is in range. Checks in postcondition should assert how existing elements of the collection are unchanged and the new element has been inserted as position index. In the postcondition, refer to the collection at the start using \old(this). requires this!= null & 0 <= index & index < size() ; ensures (\forall int i ; 0 <= i & i < index ==> get(i) == \old(this).get(i)) & (\forall int i ; index <= i & i < \old(this).size() ==> get(i+1) == \old(this).get(i)) 14

15 & get(index) == element; public void add(int index, Object element); To understand this, note that the add method puts the new element before the existing element at position index. If the list is originally e 0, e 1, e 2, e 3, e 4 and we make a call add(2, a), the new list will be e 0, e 1, a, e 2, e 3, e 4. It is not necessary to have element!= null as part of the precondition. It may be a pathological case, but nothing will go wrong if we add a null reference in place of (a reference to) an element object at some position in a list. Stephen Gilmore, Paul Jackson, Michael Fourman, April 16th,