CMPS 144 Fall 2008
Prog. Assg. #4 : Red-Blue Partitioning with Assertions
Due: 6pm, Tuesday, October 7, 2008

For this assignment, you are to augment the class RedBluePartitionerOfInt by adding methods partition2() and loopInvariant2(), which should be modeled after methods that are already there, partition1() and loopInvariant1(), respectively. You are also to complete the development of the class PrimeCompositeClassifier, which is similar to EvenOddClassifier and SmallBigClassifierOfInt in that it implements the Jave interface RedBlueClassifierOfInt Its purpose is to classify integers according to whether their absolute values are prime or composite (i.e., non-prime). (In case you forgot, a prime number is a positive integer having exactly two divisors among the positive integers: itself and one.)

With respect to the class RedBluePartitionerOfInt, the method partition1() accepts (as an argument) an array of int values and rearranges them so that the array ends up with two homogeneous segments, one containing RED values followed by one containing BLUE values. (Values are classified as being either RED or BLUE by an instance of some class that implements the RedBlueClassifierOfInt interface. Such an object is passed to the constructor of RedBluePartitionerOfInt and becomes part of the state of the object thereby initialized.)

Using N as an abbreviation for b.length, the loop invariant that guided the development of the code in partition1() was

0≤k≤m≤N && all values in b[0..k-1] are RED && all values in b[k..m-1] are BLUE

As a picture, we could depict the (conjunction of the) 2nd and 3rd conjuncts by 

    0               k                m                   N
   +---------------+----------------+-------------------+
 b |    all RED    |    all BLUE    |         ?         | 
   +---------------+----------------+-------------------+

The method partition2(), which you are to supply, should be modeled, generally, after partition1(). (The two methods have exactly the same purpose in that their their pre- and post-conditions are identical.) The difference between them is that the development of the code in partition2() should be guided by the loop invariant given by the following picture: 

    0               k                   m                N
   +---------------+-------------------+----------------+
 b |    all RED    |         ?         |    all BLUE    |
   +---------------+-------------------+----------------+
In words, this says that all values in b[0..k-1] are RED and all values in b[m..N-1] are BLUE.

In Java, execution of a command of the form

assert B

where B is a boolean expression, has no effect if B is true, but throws an AssertionError exception if B is false.

Notice that, in partition1(), there are two assert commands, each of which invokes the method loopInvariant1(). Notice also that these commands are placed in such a way that the first will be executed immediately before each iteration of the loop and the second will be executed immediately after the last iteration of the loop. As you may have guessed, loopInvariant1() returns the value true if and only if partition1()'s loop invariant is true. Hence, the purpose of the assert commands is to verify, with respect to whatever test cases we may feed to partition1(), that its loop invariant is true at those points during execution where we expect it to be true.

In analogy to loopInvariant1(), you are to supply the method loopInvariant2(), which should return the value true if and only if partition2()'s loop invariant is true. And, of course, the method partition2() should include assert commands to verify that its loop invariant is true immediately before each loop iteration and after the last one.

For the purpose of testing your work, the class RedBluePartTester is provided.

Finally, you should be aware that, by default, assert commands are ignored by Java. In order to make such a command operative, you must invoke the -source 1.4 option when compiling the class in which the command is found and you must invoke the -enableassertions (which can be abbreviated -ea) option when running an application that executes the command. Details can be found here. (This link also appears on the course web page.)