<<     >>     Contents     Help    

                                                   8.     Loopless Code II—Adverbs / and ~

The monad +/, which sums the items of its operand, is a special case of the use of the adverb / .  It is time to learn about adverbs, and other uses of this one.

Modifiers

An adverb is a modifier.  It appears to the right a noun or verb; the prototype is u a where u is the noun or verb and a is the adverb.  The compound u a is a new entity, and not necessarily the same part of speech as u .  When the compound u a is executed, it performs the function given by the definition of a and has access to u during its execution.  If u a is a verb, then it also has access to the operands of the verb during its execution; the verb u a will then be invoked as u a y if monadic or x u a y if dyadic.

You will note that I didn't have to write x (u a) y .  While J gives all verbs equal precedence and executes them right-to-left, it does give modifiers (adverbs and conjunctions) higher precedence than verbs, in the same way that C and standard mathematical notation give multiplication precedence over addition.  We will discuss the parsing rules in detail later; for now, know that modifiers are bound to their operands before verbs are executed, and that if the left operand of a modifier has a conjunction to its left (e. g. x c y a), the conjunction is bound to its arguments first, and the result of that becomes the left argument to the modifier: x c y a is (x c y) a, not x c (y a) .  In other words, modifiers associate left-to-right.  So, +"1/ (in which " is a conjunction and / is an adverb) is the same as (+"1)/, not +"(1/) .  The phrase | +/"1 (4) + i. 3 3 is executed as | ((+/"1) ((4) + (i. 3 3))), in accordance with the rule: right-to-left among verbs, but applying modifiers first.  Note that I had to put parentheses around the 4, because "1 4 would have been interpreted as rank 1 4 : collecting adjacent numbers into a list is done before anything is executed.

J includes a rich set of modifiers and even allows you to write your own, though many J programmers will never write a modifier.  We will begin our study of modifiers with the adverb monad u/ which goes by the mnemonic 'Insert'.

The Adverb Monad u/

Monad u/ (by which we mean / with a verb left operand, used as u/ y rather than as x u/ y which is dyad u/ and is completely different; note that m/ y where m is a noun is different yet), inserts u between items of y .  Monad u/ has infinite rank.  As a simple example, +/ 1 2 3 is equivalent to 1 + 2 + 3 :

   +/ 1 2 3

6

As usual, we can use fndisplay to explain what's happening:

   defverbs 'plus"0'

   plus/ 1 2 3

+---------------+

|1 plus 2 plus 3|

+---------------+

The great power of the adverb concept is that u can be any verb; it's not restricted to +, -, or any other subset of verbs (it can even be a user-written verb).  What would monad >./ mean?  Well, >./ 1 2 3 would be equivalent to 1 >. 2 >. 3; since each >. picks the larger operand, the result is going to be the largest number; so monad >./ means 'maximum':

   >./ 3 1 4 1 5 9

9

and of course 'minimum' is similar:

   <./ 3 1 4 1 5 9

1

What about monad ,/?  Convince yourself that it combines the first two axes of its operand:

   ,/ i. 2 3

0 1 2 3 4 5

   defverbs 'comma'

   comma/ i. 2 3

+-------------------+

|(0 1 2) comma 3 4 5|

+-------------------+

   i. 2 3 4

 0  1  2  3

 4  5  6  7

 8  9 10 11

 

12 13 14 15

16 17 18 19

20 21 22 23

   $ ,/ i. 2 3 4

6 4

   ,/ i. 2 3 4

 0  1  2  3

 4  5  6  7

 8  9 10 11

12 13 14 15

16 17 18 19

20 21 22 23

How many atoms are in y?  Why, */ $ y :

   */ $ i. 2 3 4

24

We can verify that the rows and columns of the following magic square sum to the same value:

   +/ 3 3 $ 8 1 6  3 5 7  4 9 2

15 15 15

   +/"1 (3 3) $ 8 1 6  3 5 7  4 9 2

15 15 15

As this last example shows, the items can be of any shape.  Applying +/ to the rank-2 array added up 1-cells, while applying +/"1 added up the 0-cells within each 1-cell.

Have you wondered what would happen if there is no cell or only 1?  Good on you if you did.  The answer is: if there is only 1 cell, the result is just that cell; if there is no cell, the result is a cell of identity elements.  The identity element i for a dyadic verb v is that value of i such that i v y is y for any choice of y .  For example, the identity element for + is 0, because 0 + y is always y .  The identity element for * is 1, and for <. is _ .  If there is no identity element for a verb v (for example, $ has no identity element), you will get a domain error if you apply v/ to an empty list.  Examples:

   +/ 0$0

0

   */ 0$0

1

Empty list; result is the identity element.

   +/ 1 3 $ 3 5 7

3 5 7

There is 1 1-cell, so the result is that cell.  This result has shape 3, not 1 3 .

   +/ 0 3 $ 0

0 0 0

There are 0 1-cells, so the result is a cell of identity elements.  Note that even though there are no cells, the cell still has a shape which is made visible by +/ .

   $/ 0$0

|domain error

|       $/0$0

If you don't want to figure out what an identity element for a verb v is you can ask the interpreter by typing v/ 0$0 .

Before we move on you should note that since v/ 1 2 3 is equivalent to 1 v 2 v 3, 2 v 3 is evaluated first: the operation starts at the end of the list and moves toward the beginning.

The adverb ~

~ is an adverb.  Like all adverbs, it has a monadic and dyadic form.  The dyadic form x u~ y is equivalent to y u x; in other words, the operands of u are reversed.  The ranks of dyad u~ are the same as those of dyad u, but with left and right rank interchanged.  For advanced J dyad ~ is indispensable; even in ordinary use it can save time and obviate the need for parentheses:

   (10 + 2) % 3

4

   3 %~ 10 + 2

4

Using %~ to mean 'y divided by x', we can have right-to-left execution without parentheses.

   -~/ 2 4

2

When we know y contains exactly  2 items, -/ y is a convenient shorthand to subtract the second from the first without having to write ({.y) - ({:y) .  To subtract the first from the second, we simply invert the order of subtraction with -~ .

The monadic form u~ y has infinite rank and is equivalent to y u y, i. e. it applies dyad u with both the left and the right operands equal to the one operand of monad u~ .  As with dyad u~, most uses of monad u~ are esoteric, but we know one already: we can sort y into ascending order with either y /: y or our new equivalent /:~ y :

   /:~ 3 1 4 1 5 9

1 1 3 4 5 9


<<     >>     Contents     Help