If you use shift and rotate, you may need to know the word-size of your machine. One way to do that is

>: 2 ^. | _1 (32 b.) 1

32

Operations Inside Boxes: u L: n, u S: n

u&.> is the recommended way to perform an operation on the contents of a box, leaving the result boxed. It is the idiom used most often by J coders and the first one to be supported by special code when performance improvements are made in the interpreter.

Sometimes your operations inside boxes require greater control than u&.> can provide. For example, you may need to operate on the innermost boxes where the boxing level varies from box to box. In these cases consider using u L: n which has infinite rank. It goes inside the operands and applies u to contents at boxing level n .

to each opened atom of y, and the result of that is boxed. The effect is that u is applied on each level-n subbox and the result replaces that subbox, with outer levels of boxing intact. For example,

]a =. 0;(1 2;3 4 5);<<6;7 8;9

The contents of each innermost box (where boxing level is 0) is replaced by the number of items there.

211

#L:1 a +-+-+---+ |1|2|+-+|

| | ||3||

| | |+-+| +-+-+---+

Each level-1 boxed entity is replaced by the number of items.

#L:2 a

+-+-+-+ |1|2|1| +-+-+-+

Similarly for level-2 entities.

# L:_2 a +-+-+---+ |1|2|+-+|

| | ||3||

| | |+-+| +-+-+---+

Negative level -n means ((level of y) minus n). Note that this does not mean 'n levels up from the bottom of each branch of y'. That would result in u's being applied at different levels in the different items of y; instead, the level at which u is to be applied is calculated using the level of the entire y .

The dyadic case x u L: n y is similar, but you need to know how the items of x and y correspond. During the recursion, as long as both x and y have a higher boxing level than the one specified in n, the atoms of x and y are matched as they would be matched in processing a verb with rank 0 0 (with replication of cells if necessary). If either operand is at the specified level, it is not changed as the items of the other operand only are opened. When both operands are at or below the specified boxing level, u is applied between them. The results of each recursion are boxed; this will give each the deeper boxing level of the two operands at each application of u .An example:

y was passed through and applied to each level-0 entity.

Once again y was applied to each entity, but because it has boxing level 2, all the results have boxing level 2.

212

The conjunction S: is like L:, but instead of preserving the boxing of the operands it accumulates all results into a list:

(0 1;<2;3) +S:0 (<<10 20) 10 21

1222

1323

Comparison Tolerance !.f

Like a diamond earring that adds a sparkle to any outfit, the fit conjunction !. is a general-purpose modifier whose interpretation is up to the verb it modifies. We have seen !.f used to specify the fill atom for a verb, and to alter the formatting of monad ": . Its other important use is in specifying the comparison tolerance for comparisons. A comparison like x = y calls two operands equal if they are close,

where close is defined as differing by no more than the comparison tolerance times the magnitude of the larger number. If you want exact comparison, you can set the comparison tolerance to 0 using !.0 :

1 (=!.0) 1.000000000000001

0

1 = 1.000000000000001

1

Tolerant comparison is used in the obvious places—verbs like dyad =, dyad >, and dyad -:—and also in some unobvious ones, like the verbs monad ~., monad ~:, and dyad i., and the adverb /. . For all of these you can specify comparison tolerance with !.f . You may wonder whether an exact comparison using !.0 is faster than a tolerant comparison. The answer is yes, but often not by much. There is one important exception: if the comparison is used for finding equal items whose rank is greater than 0 (or are complex numbers), exact comparison can be much faster. So, if x has rank 2 or higher, it's worth the trouble to write x u/.!.0 y or x i.!.0 y; similarly use ~.!.0 y, ~:!.0 y, and x e.!.0 y if y has rank greater than 0.

i.!.0 uses a completely different algorithm from dyad i. . If performance analysis shows that dyad i. is taking a lot of time, you might get an improvement by using i.!.0, even if what you are comparing is not numeric.

The f in !.f can be no larger than about 2^_34 . The reason for this is that there is much special code in J for handling integer operands, and for speed it assumes that comparison tolerance cannot affect integer comparisons.

The foreign 9!:19 y can be used to change the default comparison tolerance, and 9!:18 '' will return the current setting.

Right Shift: Monad |.!.f

One of my personal favorites is the infinite-rank verb monad |.!.f , defined as _1&(|.!.f); in other words it shifts y right one place, discarding the last item and shifting an item of fs into the first position.

213

Generalized Transpose: Dyad |:

Dyad |: has rank 1 _ . x |: y rearranges y so that the axes given in x become the last axes of the result. So, if y has rank 3, 0 |: y puts the axes of y into the order

12 13 14 15

16 17 18 19

20 21 22 23

0 |: i. 2 3 4

012

113

214

315

416

517

618

719

820

921

1022

1123

Formally, putting the axes into an order p means that (<p{x) { p |: y is the same as (<x) { y . I wish I could give you an intuitive definition but I can't.

An item of x can be negative to count axes from the end. The Dictionary shows how you can use boxed x to take elements along diagonals of y .

Monad i: and Dyad i:

Monad i: is like monad i., but its interval is centered on 0 rather than starting at 0: i: 5

_5 _4 _3 _2 _1 0 1 2 3 4 5 i: _5

5 4 3 2 1 0 _1 _2 _3 _4 _5

Monad i: can also take a complex operand to specify a different spacing between items of the result.

Dyad i: is like dyad i., but it gives the index of the last occurrence (or #x if there is none).

214