26. Loopless Code VI

The algorithms that are hardest to put into loopless form are the ones that chug through the items of an array, modifying a set of temporary variables that control the operation at each step. I am going to show you how to put one example of such an algorithm into loopless form. The resulting structure can be used for many such problems.

The example problem is a simulation. In a certain church most of the worshippers are devout, but the front pew is always packed with knaves. Collection is taken every Sunday. Each knave brings two coins to throw in, but, being a knave, he first removes the two most-valuable coins from the plate before adding his own. Given p, the contents of the plate when it reaches the front row (a list of coin-values) and k, the coins brought by the knaves (an n×2 array), what is the final contents of the plate, and what does each knave make off with? For test data, we will use

p =. 100 25 100 50 5 10

giving the contents of the plate as it enter the knaves' row, ,and

]k =. _2 ]\ 50 50 100 25 5 10 25 50 25 10 50 50 100 25

5 10

25 50

25 10

as the coins to be thrown in by the greedy knaves.

After trying for a clever solution for a little while we give up and decide we are going to have to simulate the action of each knave. We start by writing a verb knave to perform a knave's action. The design of this verb requires a little careful joinery to make it useful later: we will invoke it as x knave y where x is an item of k, i. e. the input for one knave, and y is the result from applying knave for the previous knave; the result of knave must have the same format as the y operand of knave; finally, the result of knave must include whatever we want as the final solution of the problem.

The trick is that the result of knave, which will be the input to the next invocation of knave, must carry all the information needed by the next invocation of knave; this is the way information is passed from knave to knave. The main design decision is to figure out what the format of the y operand of knave will be.

Obviously we need to know the contents of the plate as it is given to each knave. Also, the purpose of knave is to calculate what coins are removed, so those coins should be part of the result. We decide that the y operand of knave will consist of those two things, in the order (coins removed),(plate contents), and we already know that the x operand will have the format of an item of k, i. e. the knave's two coins. Now we are ready to code knave .

157

It should look at the plate-contents portion of its right argument, sort it into order of size, take the two biggest values as the result of interest, and use the rest (with the knave's own coins added) as the plate contents to be passed to the next knave. The coins that were removed are put into their place at the beginning of the result vector. In J this will be:

knave =: dyad define

xlen =. #x. NB. number of coins added/removed

splate =. \:~ xlen }. y. NB. extract plate contents, sort (xlen {. splate) , (xlen }. splate) , x. NB. build result

)

Let's test it. The y operand to the first invocation of knave will have a couple of placeholders in the place where the coins removed by the previous knave would be, followed by the initial contents of the plate. In other words,

]inity =. ({:k),p

25 10 100 25 100 50 5 10

Here we used the last item of k as a placeholder. The values don't matter but we want the right shape so the program will still work if we change the number of coins in k . Applying this value to the first knave we get

50 50 knave inity

100 100 50 25 10 5 50 50

Yes, that's right: the first two items of the result are the two dollar coins the knave took, and he threw his coins in at the end.

Before we go on we can't help noticing that taking the first two items of splate and then dropping those same items—that's needless work. We can simplify knave to

knave =: dyad : '(\:~ (#x.) }. y.) , x.'

Now we need to apply knave sequentially on all items of k . We have learned enough J to write a sentence to do that, but because this is a recurring problem I have written a conjunction LoopWithInitial to hide the complexity (we'll look at its details in a moment). This conjunction takes the verb knave, the initial value inity, and the array k and applies knave repeatedly, with each item of k taking a turn as x with the y set to the result from the previous invocation of knave :

We see the result after each application of knave (if you want to see the input alongside the result, type k ,&<"_1 res). The contents of the plate are included in res as well; we can extract the desired result simply as

158

2 {."1 res

100 100

50 50

100 50

25 25

50 25

Once you have defined the verb and the initial value, you can use LoopWithInitial to solve problems of this kind.

You may skip the rest of this chapter if you are not curious about how LoopWithInitial works. It performs the following steps:

Since the initial value is going to be appended to the y operand, and they have dissimilar shapes, it is necessary to box each item of y as well as the initial value. Once the items of y are boxed, they are put into reverse order, because as we have seen u/\. is much faster than u/\ . Then the initial value is appended to the reversed boxed y . With that preparation complete, the operation can be performed: u.&.>/\. applies u.&.> (in words: unbox each operand, apply u., and rebox) starting at the end of the reversed y . The first application of u.&.> will be between the original first element of y and the initial value; the next application will be between the original second element of y and the result of the first application; and so on. The results from the applications of u.&.> are collected in an array. Finally, the preparation steps are undone, discarding the initial value, reversing the array into original order, and unboxing the result.

The actual implementation of LoopWithInitial is a bit more elegant than that schematic representation. Observe that step 7 is the inverse of step 1, step 6 of 2, and step 5 of 3; each pair is an opportunity to use u&.v, and the actual verb produced by

LoopWithInitial is:

knave LoopWithInitial inity

knave&.>/\.&.(,&(<25 10 100 25 100 50 5 10))&.|.&.(<"_1) which performs all the steps of the longer form. We will examine this conjunction in a later chapter.

You may object that since the left operand of LoopWithInitial is applied to each item, it still has to be interpreted for each item, so nothing is gained by avoiding the loop. An astute observation, but in the second part of this book we will learn how to write verbs that are not reinterpreted for each item.

159

Finally, you may observe that the temporary vector, which only needs to be a list, turns into a rank-2 array by the time we have passed it through each item. Doesn't that waste a lot of space? Yes, it does, and if your problem is big enough that the space matters, you may have a valid application for a loop. An alternative would be to make the temporary vector a public variable accessed by knave in the same way that temporary variables would be used in C.

160

27. Loopless Code VII—Sequential

Machines

J provides a primitive to handle one class of programs, ill-suited for parallel processing, that can be described systematically: sequential machines. Dyad ;: takes a sequential-machine description in x and a stream of input in y, and produces the result called for by the machine description.

A brief overview is as follows. The output array is initialized to empty. An initial row number (also called a state number) is chosen. Each item of input is converted into a column number. The column numbers are processed, one per iteration. In an iteration, the next column number is supplied to the row/action table: the row number and column number specify an item of the table, which is a 2-element vector giving the new row number and an action code. The action is performed and the row number is updated, completing the iteration. Execution continues until a 'quit' action is encountered or all the column numbers have been supplied. At that point the output array, which contains the accumulated results of the actions performed, becomes the result of the verb.

To illustrate the use of dyad ;: we will build a machine to recognize hex constants in character input. A hex constant will be '0x' followed by any positive number of hexadecimal digits; we will extract the digits and discard the '0x'.

The x argument to dyad ;: is a boxed list f;s;m;ijr . m and ijr may be omitted.

m controls the conversion of the items of y to column numbers. In the general case, m is a list of boxes; then the column number produced for an item of y is the index of the first box of m whose contents have an item equal to the item of y (if there is no such box, a column number of #m is used). If y is a string, m may be a numeric list containing one column number for each character code and the column numbers are (a. i. y) { m . If y is numeric, m may be empty or omitted, and y specifies the column numbers directly.

In our example problem, we see that the input characters are in 4 classes: the character 0; the character x, the hexadecimal characters 0123456789abcdefABCDEF, and all other characters. We will assign these column numbers 3, 2, 1, and 0 respectively. The conversion control m can be generated by the statements

m =. a. e. '0x123456789abcdefABCDEF' m =. m + a. e. '0x'

m =. m + a. e. '0' and can be verified by

(a. i. '0x2aq') { m 3 2 1 1 0

ijr gives the initial values of 3 variables used by the sequential machine: the input pointer i, the word pointer j, and the row number r. The input pointer is the index in y of

161

the next item to be processed, and is incremented by 1 at the end of each iteration. The word pointer is the index in y of the first item in the current word; when the action code calls for producing output, the output will start with item j. When j is _1, there is no current word. The row number, as noted above, is used to index the row/action table. If ijr is omitted, it defaults to 0 _1 0, which means start processing the first item of y, with no current word, and starting in row number 0. This default is acceptable for our example problem.

s gives the row/action table. This table has as many rows as needed to encode all the states of the sequential machine, and as many columns as there are possible columns numbers of mapped input. Each 1-cell of s is a 2-element list. The first element will become the row number for the next iteration. The second is the action code, indicating the action to be performed. The action code is a number from 0 to 6, with meanings as follows:

Executing an 'add' action when j is _1 produces a domain error.

The action code indicates when a value is appended to the output array. The value that is appended depends on the f parameter (which came from the x argument to dyad ;:) and the values of the iteration variables. The values appended for different values of f are (r=row number, c=column number, j=word pointer, i=input pointer):

162

The indicated data is appended to the output array whenever an 'add single word' action is executed. The 'add multiple words' action also adds the data to the output except that a sequence of consecutive 'add multiple words' actions executed from the same row causes only a single item to be added to the output array: the 'add multiple words' actions executed after the first one modify the item that was added by the first, appending the new word within the previously appended item.

After the last iteration, if no 'stop' action has been encountered and j is not _1, one final 'emit multiple words' action is performed.

We can build the state table s for our sample problem now. There will be 4 rows. First, we wait for 0; then we expect x; then we expect a hexadecimal digit, signaling start-of-word if we see it; then we wait for a non-hexadecimal-digit, and output the word when we get one. The state table will look like this:

(0;s;m) ;: 'qqq0x30x30x40x0xxxx' +--+--+ |30|40| +--+--+

(0;s;m) ;: 'qqq0x30x30x40x0x34a' +--+--+---+

|30|40|34a| +--+--+---+

163