# 17. To Summarise

• By Eugene McDonnell. First published in Vector, 15, 1, (August 1998), 132-137.

The key adverb in J, represented by slashdot (/.) is defined in the Dictionary as:

`x u/.y  is  (=x) u@# y`

that is, items of x specify keys for corresponding items of y and u is applied to each collection of y having identical keys. For example:

```   1 2 3 1 3 2 1 </. 'abcdefg'
+---+--+--+
+---+--+--+```

This may be clearer if we look at the separate parts.

```  =x
1 0 0 1 0 0 1
0 1 0 0 0 1 0
0 0 1 0 1 0 0```

The first row of this has 1s in the first, fourth, and seventh positions, so when used as the left argument to copy (the dyad of #), and applied to y , yields its first, fourth, and seventh items, or 'adg' ; similarly the second row yields 'bf' and the third row yields 'ce' . Each of these is then boxed and the three are catenated together, yielding

```+---+--+--+
+---+--+--+```

The basic idea remains the same when u changes from box to a different monad. For example, if we replace box by tally (the monad of #) we get:

```  x #/. y
3 2 2```

The same three groupings are selected, but instead of being boxed they are tallied, or counted, yielding the count of each group; three in the first, and two in the second and third.

The key adverb was not in the initial version of J. It came in later at the request of the J user community, notably Joey Tuttle. Joey's interests were not merely theoretical; he had practical ends in view. He was in the business of analyzing huge amounts of data and summarizing time and amount fields by accounts. We'll use an abbreviated version so we can fit the data onto a small page. Suppose we have three accounts, 1001, 1002, and 1003, and suppose further that we have a table whose rows give an account number and an amount:

```   acct=:1001 1002 1003

table=:((?10#3){acct),.?10#100

table
1001 51
1003 83
1002  3
1002  5
1001 52
1001 67
1003  0
1003 38
1003  6
1002 41```

To summarize this table by account, we transpose (|:) it, so that the accounts are in the first row, and the amounts in the second, then insert (/) sum key (+//.) between the account row and the amount row:

```   +//./|:table
170 127 49```

If you check the first amount in the sum, 170, you can verify that it is indeed the sum of the three amounts associated with the first occurring account, 1001, that is, it is the sum of 51, 52, and 67. Similarly the second amount 127, is the sum of the four amounts associated with the second occurring account, 1003, that is, it is the sum of 83, 0, 38, and 6. Lastly, the third amount, 49, is the sum of the three amounts associated with the third occurring account, 1002, that is, 3, 5, and 41.

This result may not be completely satisfactory, since the amounts are not in the order of the accounts: they are in the order in which they fortuitously occur in the table. One way to remedy this is to place some dummy rows at the beginning of the table, one for each account, with the accounts in the desired order, and with the amounts set to zero (acct,.0) .

```  (acct,.0),table
1001  0
1002  0
1003  0
1001 51
1003 83
1002  3
1002  5
1001 52
1001 67
1003  0
1003 38
1003  6
1002 41```

Now when we summarize the amounts will be in account order.

```   +//./|:(acct,.0),table
170 49 127```

We can produce a summary of accounts and amounts by prefacing the above with the list of account numbers and stitching (,.) the lists together.

```   acct,.+//./|:(acct,.0),table
1001 170
1002  49
1003 127```

This gives you the theory and the practice of the key adverb, so it's time to play, and incidentally to learn another way to use key.

How are the digits of pi distributed? If the digits were distributed evenly, then the frequency of occurrence of all digits would be about 10%. J enables you to compute as many digits of pi as you have room for and time for. A convenient way to obtain n digits of pi is to subtract 1 (<:) from n , make this an extended integer (x:) use this as an exponent of 10 (10^), apply floor atop pi times (<.@o.) and take the format (":) of this:

`   dp=: monad def '":<.@o.10^x:<:y'   NB. digits of pi`

Try this on a small integer:

```   q10=:dp 10

q10
3141592653```

This is correct. Try it on a somewhat larger integer:

```   q30=:dp 30

q30
314159265358979323846264338327```

Checking this against the value of pi to many places in a table such as may be found in a volume of Knuth's The Art of Computer Programming shows that q30 is accurate, too.

Let's compute some more (q3000 may take several minutes):

```   q100=:dp 100

q300=:dp 300

g1000=:dp 1000

q3000=:dp 3000```

Now let's see how the digits are distributed in each of these, in order. We need a digit distribution function, This is where a new use of key comes in. In order to make the result of the digit distribution function be in the right order, we'll preface the argument with d , a list of the decimal digits in order.

`   d=:'0123456789'`

To get the distribution we preface the formatted digits of pi with d (d,y) ,  then apply count (#) key (/.) reflexive (~) to this, giving us the distribution of d,y , then subtract 1 (<:) to adjust the count for the presence of d .

`   dd=: monad def '<:#/.~d,y'`

And try this out on q10 , which is easy to verify by eye:

```   /:~q10
1123345569
dd q10
0 2 1 2 1 2 1 0 0 1```

No zeros, two ones, one two, two threes, one four, two fives, one six, no sevens or eights, and one nine. Now let's see the digit distribution of each of the other lists of pi digits.

```   dd q30
0 2 4 7 3 3 3 2 3 3

dd q100
8 8 12 12 10 8 9 8 12 13

dd q300
26 30 35 31 37 27 31 19 34 30

dd q1000
93 116 103 103 93 97 94 95 101 105

dd q3000
259 308 303 266 318 315 302 287 310 332```

These look somewhat reasonable, but it would be better to see how closely each gets to having 10% of each digit, using a function pd , which takes a distribution as argument, and yields the percentage of each value, rounded to the nearest one per cent. Do this by dividing the values by the sum of the values (y%+/y) , multiply this by 100 (100*) , to get percentages, and round, getting the nearest percentage, by adding a half (0.5+) and taking the floor (<.) .

```   pd=: monad def '<.0.5+100*y%+/y'

pd dd q10
0 20 10 20 10 20 10 0 0 10```

We can compare this to dd q10 and see that it is simply the same values multiplied by 10 to give percentages, as desired. There are so few digits to take into account that it is difficult to say whether the distribution is even or not. Trying the next distribution, of thirty values, still leaves us uncertain.

```   pd dd q30
0 7 13 23 10 10 10 7 10 10```

There are no zeros among the first thirty digits, and a lot of threes. Probably still not enough digits.

```   pd dd q100
8 8 12 12 10 8 9 8 12 13```

Except for the large number of nines, this is beginning to look quite even.

```   pd dd q300
9 10 12 10 12 9 10 6 11 10```

Here, the number of sevens seems too low. Let's keep looking.

```   pd dd q1000
9 12 10 10 9 10 9 10 10 11```

Ones seem a bit high, but I'd say this distribution is even enough.

```   pd dd q3000
9 10 10 9 11 11 10 10 10 11```

With 3000 digits to distribute, we can say with some satisfaction that this represents an even distribution. Before we part, let's looks at a consecutive portion of these digits:

```   (762+i.6){d1000
999999```

Hmmm. Well, yes, that's not too unusual.

Doc/Articles/Play151 (last edited 2010-10-16 05:11:53 by IanClark)