Power-Programmierung/CD1.mdf/j/dos/boxed.txt

Text File | 1992-12-07 | 30KB | 911 lines

                              Using J's Boxed Arrays

                                Donald B. McIntyre
                              Luachmhor, Church Road
                             Kinfauns, Perth PH2  7LD
                                 Scotland - U.K.
                             Telephone:  [phone]


        Introduction:

        APL, which has been an implemented computer language for more than
        25 years, grew out of the concise mathematical notation devised by
        Kenneth Iverson.   J is his powerful new dialect [1].   He has
        defined it in a Dictionary that is an essential reference [2].
        Iverson has extended the language in interesting ways.   He has
        also rationalised features which, benefiting from so many years of
        hindsight, he recognised as anomalies in earlier versions of APL.
        Users accustomed to APL can therefore expect to be puzzled by
        changes of behaviour.   For example, the sum over a table (+/
        table) formerly gave row totals (summing over the last axis), but
        the same expression in J gives column totals (summing over the
        first axis).   The reason is that the table is considered an array
        of items, each row being an item.   The number of items is given
        by the tally (#) or by the first number or head ({.) of the shape
        ($);  a 4 by 12 table (matrix) is looked on as a collection of 4
        lists (vectors), each of length 12.   Consequently the mean (sum
        divided by tally) is the sum down the columns (across the items)
        divided by the number of rows.

        The use of square brackets and semicolon in indexing is anomalous;
        e.g. expressions such as  V[I] or M[I;J] do not have the syntax of
        other verbs (functions).   J uses normal syntax;  e.g.  i { v
        (which can be read as "i from v").   In higher rank objects, which
        need pairs (or triplets, etc) of indexes to identify one atom in
        the array, the syntax is the same, but indexes identifying a
        single cell are boxed together.   Examples follow.

        Thinking that my experience with J might help others, I have given
        accounts of various applications [4-7].   This further example
        describes one of my first attempts -- the use of boxes to create a
        small database.   Eugene McDonnell responded to my questions in a
        helpful letter, which I included in my paper for APL91 [4].


        Basic Techniques Relating to Boxes::

        APL's index generator (iota) has been extended:
           ]a=. i.2 3
        0 1 2
        3 4 5

        After being boxed, this table of 2 rows (each of length 3) behaves
        as an atom (scalar):




                                       -1-




           $a
        2 3
           ]b=. <i.2 3
        ┌─────┐
        │0 1 2│
        │3 4 5│
        └─────┘
           $b


        Boxes also result from link (;)
           ]c=. 'mary';'jones';a; 1 3 5
        ┌────┬─────┬─────┬─────┐
        │mary│jones│0 1 2│1 3 5│
        │    │     │3 4 5│     │
        └────┴─────┴─────┴─────┘
        From this list of 4 items we can make a selection:
           $c
        4
           3 1 2 0{c
        ┌─────┬─────┬─────┬────┐
        │1 3 5│jones│0 1 2│mary│
        │     │     │3 4 5│    │
        └─────┴─────┴─────┴────┘

        Individual words are boxed by word formation (;:)
           ;:s=. 'here we go gathering nuts in may'
        ┌────┬──┬──┬─────────┬────┬──┬───┐
        │here│we│go│gathering│nuts│in│may│
        └────┴──┴──┴─────────┴────┴──┴───┘
        The length of each word is found by applying tally under open;
        i.e. each box is opened, the tally is taken, and the box is closed
        again.   under (&.) is a conjunction, in this case combining tally
        (#) and open (>).
            wl=. #&.>@;:

























                                       -2-




            wl s
        ┌─┬─┬─┬─┬─┬─┬─┐
        │4│2│2│9│4│2│3│
        └─┴─┴─┴─┴─┴─┴─┘

        If f, g, h are verbs to be applied to a list of numbers, y, then
           (f g h) y   is the same as    (f y) g (h y)

        This train of three verbs is called a fork, and the mean is an
        example [4-7].   The average word-length is found by applying the
        verb mean after opening the boxes containing word-lengths.
           mean=. +/%#
           mean > wl s
        3.71429

        Or, defining the verb mwl we get the mean word-length of any
        string.   This is a tacit definition, a pure functional form, with
        no explicit reference to the arguments.
           mwl=. mean@(>@wl)       NB.  Parentheses are required!
           mwl s
        3.71429

        When we open a list of boxes we get a table:
           > ;:s
        here
        we
        go
        gathering
        nuts
        in
        may

        The table is alphabetised by the dyadic verb sort (/:) using the
        adverb both (~) so that the left and right arguments are the same.
           sort=. /:~@(>@;:)     NB.  Parentheses are required!
           sort s
        gathering
        go
        here
        in
        may
        nuts
        we

        We must distinguish between boxing the list as a whole and boxing
        the individual items.   The rank conjunction (") instructs the box
        verb to enclose elements of specified rank (in this case  atoms):
           v=. 2 3.4 5.67
           <"0 v
        ┌─┬───┬────┐
        │2│3.4│5.67│
        └─┴───┴────┘
        The items (in this case individual numbers) are made into vectors
        (raised from rank-0 to rank-1) by ravel item (,.)
           ,. v
           2




                                       -3-




         3.4
        5.67

        A rank-3 array can be boxed with any rank from 0 to 3:
           ]m=. 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
           <"2 m
        ┌─────────┬───────────┐
        │0 1  2  3│12 13 14 15│
        │4 5  6  7│16 17 18 19│
        │8 9 10 11│20 21 22 23│
        └─────────┴───────────┘
           <"1 m
        ┌───────────┬───────────┬───────────┐
        │0 1 2 3    │4 5 6 7    │8 9 10 11  │
        ├───────────┼───────────┼───────────┤
        │12 13 14 15│16 17 18 19│20 21 22 23│
        └───────────┴───────────┴───────────┘




































                                       -4-




        Construct a Simple Database:

        Use "link" (;) to create the database as an array of boxed
        elements:
           d=.,:'E.E.';'McDonnell';'Palo Alto';27;10000; 8 3 12 25 10
           d=.d,'Ken';'Iverson';'Toronto';55;15000; 4 19 32 1 15 10
           d=.d,'Donald';'McIntyre';'U.K.';61;12000;''
           d=.d,'Roger';'Hui';'Toronto';49;20000; 32 4
           d=.d,'Anthony';'Camacho';'U.K.';45;35000; 19 23 45 4 17 13 5
           d
        ┌───────┬─────────┬─────────┬──┬─────┬──────────────────┐
        │E.E.   │McDonnell│Palo Alto│27│10000│8 3 12 25 10      │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Ken    │Iverson  │Toronto  │55│15000│4 19 32 1 15 10   │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Donald │McIntyre │U.K.     │61│12000│                  │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Roger  │Hui      │Toronto  │49│20000│32 4              │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Anthony│Camacho  │U.K.     │45│35000│19 23 45 4 17 13 5│
        └───────┴─────────┴─────────┴──┴─────┴──────────────────┘

        The columns can be taken as First Name, Family Name, Location,
        Age, and Salary.   The final column illustrates a ragged array
        with one empty cell.   (The content of the database is
        fictitious.)

        We can extract columns:
           col=. >@{"1
           locality=. 2&col
           locality d
        Palo Alto
        Toronto
        U.K.
        Toronto
        U.K.

        Pronouns might be convenient:
           name=. 1 [ age=. 3 [ salary=. 4

        Because x is sorted into an order specified by y,  x /: y  is the
        same as  (/:y) { x  See [2]:
           sort=. ] /: col          NB.   Fork

        It is important to remember that right (]) and left ([) are verbs
        and not merely placeholders;  they take arguments and produce
        results.

           name sort d
        ┌───────┬─────────┬─────────┬──┬─────┬──────────────────┐
        │Anthony│Camacho  │U.K.     │45│35000│19 23 45 4 17 13 5│
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Roger  │Hui      │Toronto  │49│20000│32 4              │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Ken    │Iverson  │Toronto  │55│15000│4 19 32 1 15 10   │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤




                                       -5-




        │E.E.   │McDonnell│Palo Alto│27│10000│8 3 12 25 10      │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Donald │McIntyre │U.K.     │61│12000│                  │
        └───────┴─────────┴─────────┴──┴─────┴──────────────────┘

           salary sort d
        ┌───────┬─────────┬─────────┬──┬─────┬──────────────────┐
        │E.E.   │McDonnell│Palo Alto│27│10000│8 3 12 25 10      │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Donald │McIntyre │U.K.     │61│12000│                  │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Ken    │Iverson  │Toronto  │55│15000│4 19 32 1 15 10   │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Roger  │Hui      │Toronto  │49│20000│32 4              │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Anthony│Camacho  │U.K.     │45│35000│19 23 45 4 17 13 5│
        └───────┴─────────┴─────────┴──┴─────┴──────────────────┘

        To sort on the basis of the ragged column (5), we might use the
        mean:
           mean age col d
        47.4
           mean salary col d
        18400

        Using under to define the adverb each
           each=. &.>
           meanr=. mean each@(5&{"1)     NB.  Means in ragged column 5
           meanr d
        ┌────┬────┬─┬──┬──┐
        │11.6│13.5│0│18│18│
        └────┴────┴─┴──┴──┘

        Sorting on the basis of the means in the ragged column, and
        appending the means:
           sortr=. ] /: >@meanr
           sortr d,"1 0 meanr d
        ┌───────┬─────────┬─────────┬──┬─────┬──────────────────┬────┐
        │Donald │McIntyre │U.K.     │61│12000│                  │0   │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┼────┤
        │E.E.   │McDonnell│Palo Alto│27│10000│8 3 12 25 10      │11.6│
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┼────┤
        │Ken    │Iverson  │Toronto  │55│15000│4 19 32 1 15 10   │13.5│
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┼────┤
        │Roger  │Hui      │Toronto  │49│20000│32 4              │18  │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┼────┤
        │Anthony│Camacho  │U.K.     │45│35000│19 23 45 4 17 13 5│18  │
        └───────┴─────────┴─────────┴──┴─────┴──────────────────┴────┘

        Append (,"1 0) is performed here so that rank-1 cells (rows) on
        the left are joined to rank-0 cells (atoms) on the right.

        To display the data on people at a given locality, apply the
        adverb each to the verb match (-:).   Because the data are boxed,
        the search-key must be boxed too.   Copy (the dyadic #) does the
        same as compress or replicate in older APL.   The adverb cross (~)
        interchanges the arguments, thus cutting down on parentheses:



                                       -6-





           d #~ >(<'Toronto') -: each 2{"1  d
        ┌─────┬───────┬───────┬──┬─────┬───────────────┐
        │Ken  │Iverson│Toronto│55│15000│4 19 32 1 15 10│
        ├─────┼───────┼───────┼──┼─────┼───────────────┤
        │Roger│Hui    │Toronto│49│20000│32 4           │
        └─────┴───────┴───────┴──┴─────┴───────────────┘

        The following verb makes selections easier:
           place=. ] #~ >@(<@[ -: each 2&{"1 @ ])

           'U.K.' place d
        ┌───────┬────────┬────┬──┬─────┬──────────────────┐
        │Donald │McIntyre│U.K.│61│12000│                  │
        ├───────┼────────┼────┼──┼─────┼──────────────────┤
        │Anthony│Camacho │U.K.│45│35000│19 23 45 4 17 13 5│
        └───────┴────────┴────┴──┴─────┴──────────────────┘











































                                       -7-




        Replacement and Insertion:

        We first assign a "linear index" to each cell:
              i. $ d
         0  1  2  3  4  5
         6  7  8  9 10 11
        12 13 14 15 16 17
        18 19 20 21 22 23
        24 25 26 27 28 29

              li=. [ { i.@$@]      NB.  Linear Index.   Fork

              1 4 li d             NB.  Rows 1 and 4
         6  7  8  9 10 11
        24 25 26 27 28 29

              (<2 5) li d    NB.  Linear index of cell at row 2 and column
        5
        17

              (2 5;4 2) li d     NB.  Scattered indexing
        17 26

        The verb from ({) is used to select information.   Placing
        information into an existing cell is a more complicated process.
        We use the adverb amend (}), and we need three pieces of
        information:  the array to be changed;  the indexes identifying
        the affected cells;  and the new data to be inserted.

        The indexes will normally be computed from the data, but we can
        arbitrarily select any cell;  e.g. to place an array into the cell
        at row-2 column-5:

           x=. 9 8 7 6,:5 4 3 2
           (<x) ((<2 5) li d)}d
        ┌───────┬─────────┬─────────┬──┬─────┬──────────────────┐
        │E.E.   │McDonnell│Palo Alto│27│10000│8 3 12 25 10      │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Ken    │Iverson  │Toronto  │55│15000│4 19 32 1 15 10   │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Donald │McIntyre │U.K.     │61│12000│9 8 7 6           │
        │       │         │         │  │     │5 4 3 2           │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Roger  │Hui      │Toronto  │49│20000│32 4              │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Anthony│Camacho  │U.K.     │45│35000│19 23 45 4 17 13 5│
        └───────┴─────────┴─────────┴──┴─────┴──────────────────┘

        Scattered indexing presents no problem:
           (x;'London') ((2 5;4 2)li d)} d
        ┌───────┬─────────┬─────────┬──┬─────┬──────────────────┐
        │E.E.   │McDonnell│Palo Alto│27│10000│8 3 12 25 10      │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Ken    │Iverson  │Toronto  │55│15000│4 19 32 1 15 10   │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Donald │McIntyre │U.K.     │61│12000│9 8 7 6           │




                                       -8-




        │       │         │         │  │     │5 4 3 2           │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Roger  │Hui      │Toronto  │49│20000│32 4              │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Anthony│Camacho  │London   │45│35000│19 23 45 4 17 13 5│
        └───────┴─────────┴─────────┴──┴─────┴──────────────────┘


        Expansion in General, and a Digression on Reading J:

        To insert new items (new rows) the database must be expanded.   In
        older APL the back-slash (\) was used along with a boolean string
        (U), as in U\[0]D to expand along the first axis. J uses the back-
        slash for other operations, but Iverson has defined a verb that
        performs the operation of expansion [4]:

              exp=. /:@\:@[{#@[{.]
              1 0 1 exp 7 8
        7 0 8

        To someone unfamiliar with the notation, this expression is, of
        course, incomprehensible.   This, however, is not a reason for
        supposing it to be difficult.   Parse any sentence as a step
        towards understanding it.   Characters immediately followed by a
        period (.) or a colon (:) are taken as 2-character symbols.   Make
        this clear by inserting spaces and note the sequence of 11
        symbols:
              exp=. /: @ \: @ [ { # @ [ {. ]

        Square brackets ([) and (]) are not punctuation symbols (as round
        parentheses are), but verbs returning their left and right
        arguments respectively.

        There being no adverbs (mondadic operators), next identify
        conjunctions (dyadic operators) -- in this case only atop (@) --
        and insert parentheses to show that a conjunction combines the
        item (verb or noun) on either side of it to compose a new verb.
        Put the right parentheses in first:
              exp=. /: @\:) @ [) { # @[) {. ]

        Conjunctions have long left-scope and short right-scope;  for this
        reason, put in the left parentheses while working from left to
        right.   Confirm that this gives the same result as before.
              exp=. ((/:@\:)@[) { (#@[) {. ]

        The expressions enclosed in parentheses are new verbs resulting
        from the composition of simple verbs, consequently we can now view
        the definition as a sequence of 5 verbs:

              p=. /:@\:@[
              q=. {
              r=. #@[
              s=. {.
              t=. ]

              1 0 1 (p q r s t) 7 8




                                       -9-




        7 0 8

        Such a sequence of verbs previously had no meaning.   Iverson
        calls it a train:  "an isolated sequence of parts of speech that
        does not resolve to a shorter sequence through the normal
        application of verbs" [2, p.5].   He assigns meanings to trains of
        two verbs (hooks) and three verbs (forks), and by repeated
        resolution to any train of verbs [2, 8, 9].   Thus
              (s t)            NB.   Hook
        ┌─┬─┐
        │s│t│
        └─┴─┘
              (r s t)          NB.   Fork
        ┌─┬─┬─┐
        │r│s│t│
        └─┴─┴─┘
              (q r s t)        NB.   Hook containing a Fork
        ┌─┬───────┐
        │q│┌─┬─┬─┐│
        │ ││r│s│t││
        │ │└─┴─┴─┘│
        └─┴───────┘
              (p q r s t)      NB.   Fork containing a Fork
        ┌─┬─┬───────┐
        │p│q│┌─┬─┬─┐│
        │ │ ││r│s│t││
        │ │ │└─┴─┴─┘│
        └─┴─┴───────┘


        J provides two tools for investigating parsing.   The directly
        displayed form shows a fork within a fork:
           exp
        ┌───────────────┬─┬──────────────┐
        │┌─────────┬─┬─┐│{│┌───────┬──┬─┐│
        ││┌──┬─┬──┐│@│[││ ││┌─┬─┬─┐│{.│]││
        │││/:│@│\:││ │ ││ │││#│@│[││  │ ││
        ││└──┴─┴──┘│ │ ││ ││└─┴─┴─┘│  │ ││
        │└─────────┴─┴─┘│ │└───────┴──┴─┘│
        └───────────────┴─┴──────────────┘

        The conjunction (5!:4) displays a tree representation:
              tree=. 5!:4 @ <
              f=. p q r s t
              tree 'f'
              ┌─ p
              ├─ q
        ─ f ──┤    ┌─ r
              └────┼─ s
                   └─ t

           tree 'exp'
                            ┌─ /:
                      ┌─ @ ─┴─ \:
                ┌─ @ ─┴─ [
                ├─ {




                                       -10-




        ─ exp ──┤           ┌─ #
                │     ┌─ @ ─┴─ [
                └─────┼─ {.
                      └─ ]

        In reading the tree, remember that the conjunction atop (@) makes
        verbs.   Hooks and forks, on the other hand are trains of verbs.

        Returning to the original form without parentheses:
              exp=. /: @ \: @ [ { # @ [ {. ]

        In Iverson's words:  "Notice how this tacit definition reads in
        English.   The inverse of the downgrade of the left argument
        permutes the (over)take of the right argument by the number of
        items of the left argument" [4, p.270].

        Had an adverb (a monadic operator) been present, we would have
        inserted parentheses to show that it modified the verb to its
        left.   This is illustrated by the adverb each in the verb meanr,
        which we used to compute the means of the ragged items in column
        5:
           meanr=. mean each @ (5&{"1)

        Note first that parentheses are required to prevent the atop (@)
        from grabbing the 5 to its right.   Next, the conjunction with (&)
        takes the 5 on its left along with the verb from ({) on its right
        to compose a new verb.   The rank conjunction (") takes this
        composed verb (including the 5 that is part of it) and combines it
        with the noun (1) to its right.   The result (5&{"1) is a verb
        that returns the fifth column of the array to which it applies.

        each is a defined adverb, which, like any other adverb, modifies
        the verb to its left (mean) to compose a new verb (mean each).
        This verb is the left argument of the conjunction atop.

        Had we defined meanr:
           meanr=. +/%# each @ (5&{"1)

        then each would have modified tally (#) alone, and the definition
        would have been parsed as a fork, which would have been quite
        wrong:
           (+/) % (# each @ (5&{"1))


        Adding New Items to the Database:

        First expand the array:
           ] e=. 1 0 1 1 0 1 1 exp d
        ┌───────┬─────────┬─────────┬──┬─────┬──────────────────┐
        │E.E.   │McDonnell│Palo Alto│27│10000│8 3 12 25 10      │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │       │         │         │  │     │                  │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Ken    │Iverson  │Toronto  │55│15000│4 19 32 1 15 10   │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Donald │McIntyre │U.K.     │61│12000│                  │




                                       -11-




        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │       │         │         │  │     │                  │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Roger  │Hui      │Toronto  │49│20000│32 4              │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Anthony│Camacho  │U.K.     │45│35000│19 23 45 4 17 13 5│
        └───────┴─────────┴─────────┴──┴─────┴──────────────────┘

        Then amend by inserting the new items one at a time:
           t=. e (1 li d)}~  'Bob';'Bernecky';'Toronto';35;22000; 4 5
           t (4 li d)}~  'Graham';'Woyka';'U.K.';62;35000; 14 31 5 7

        ┌───────┬─────────┬─────────┬──┬─────┬──────────────────┐
        │E.E.   │McDonnell│Palo Alto│27│10000│8 3 12 25 10      │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Bob    │Bernecky │Toronto  │35│22000│4 5               │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Ken    │Iverson  │Toronto  │55│15000│4 19 32 1 15 10   │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Donald │McIntyre │U.K.     │61│12000│                  │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Graham │Woyka    │U.K.     │62│35000│14 31 5 7         │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Roger  │Hui      │Toronto  │49│20000│32 4              │
        ├───────┼─────────┼─────────┼──┼─────┼──────────────────┤
        │Anthony│Camacho  │U.K.     │45│35000│19 23 45 4 17 13 5│
        └───────┴─────────┴─────────┴──┴─────┴──────────────────┘

        Or define another array, from which to amend the original by
        merging several items in one step:
        x=.('Graham';'Woyka';'U.K.';1;2;3),:'Vin';'Grannell';'Los
        Angeles';4;5;6 7 8

           x (1 4 li d)} e
        ┌───────┬─────────┬───────────┬──┬─────┬──────────────────┐
        │E.E.   │McDonnell│Palo Alto  │27│10000│8 3 12 25 10      │
        ├───────┼─────────┼───────────┼──┼─────┼──────────────────┤
        │Graham │Woyka    │U.K.       │1 │2    │3                 │
        ├───────┼─────────┼───────────┼──┼─────┼──────────────────┤
        │Ken    │Iverson  │Toronto    │55│15000│4 19 32 1 15 10   │
        ├───────┼─────────┼───────────┼──┼─────┼──────────────────┤
        │Donald │McIntyre │U.K.       │61│12000│                  │
        ├───────┼─────────┼───────────┼──┼─────┼──────────────────┤
        │Vin    │Grannell │Los Angeles│4 │5    │6 7 8             │
        ├───────┼─────────┼───────────┼──┼─────┼──────────────────┤
        │Roger  │Hui      │Toronto    │49│20000│32 4              │
        ├───────┼─────────┼───────────┼──┼─────┼──────────────────┤
        │Anthony│Camacho  │U.K.       │45│35000│19 23 45 4 17 13 5│
        └───────┴─────────┴───────────┴──┴─────┴──────────────────┘

        Or, finally, amend the database by merging a selection from
        another database with equivalent fields:
           e (1 4 li e)}~ 1 0{ x
        ┌───────┬─────────┬───────────┬──┬─────┬──────────────────┐
        │E.E.   │McDonnell│Palo Alto  │27│10000│8 3 12 25 10      │
        ├───────┼─────────┼───────────┼──┼─────┼──────────────────┤




                                       -12-




        │Vin    │Grannell │Los Angeles│4 │5    │6 7 8             │
        ├───────┼─────────┼───────────┼──┼─────┼──────────────────┤
        │Ken    │Iverson  │Toronto    │55│15000│4 19 32 1 15 10   │
        ├───────┼─────────┼───────────┼──┼─────┼──────────────────┤
        │Donald │McIntyre │U.K.       │61│12000│                  │
        ├───────┼─────────┼───────────┼──┼─────┼──────────────────┤
        │Graham │Woyka    │U.K.       │1 │2    │3                 │
        ├───────┼─────────┼───────────┼──┼─────┼──────────────────┤
        │Roger  │Hui      │Toronto    │49│20000│32 4              │
        ├───────┼─────────┼───────────┼──┼─────┼──────────────────┤
        │Anthony│Camacho  │U.K.       │45│35000│19 23 45 4 17 13 5│
        └───────┴─────────┴───────────┴──┴─────┴──────────────────┘


        Acknowledgements:

        Kenneth Iverson and Roger Hui provided the language and the
        system.   I am particularly indebted to Kenneth Iverson and Eugene
        McDonnell for sharing their trenchant insight at crucial points in
        my experience with J.

        References

            [1]    J is available from Iverson Software Inc., 33 Major
                  Street, Toronto, Ontario, Canada M5S  2K9.   Phone (416)
                  925-6096; Fax [phone].   This paper was submitted
                  in November 1991.   The examples, originally executed
                  with J Version 3.3 have been revised for compatibility
                  with Version 4.2.

            [2]    Kenneth E. Iverson, ISI Dictionary of J, Version 4 with
                  Tutorials, Iverson Software Inc., Toronto (1991) 34pp.

            [3]    Kenneth E. Iverson, Arithmetic, Iverson Software Inc.,
                  Toronto (1991) 119pp.

            [4]    Donald B. McIntyre, Mastering J, APL91 Conference
                  Proceedings, Stanford, California, August 1991.   APL
                  Quote Quad Vol. 21 Number 4 (August 1991), p.264-273.
                  This paper includes valuable statements by K.E. Iverson
                  and E.E. McDonnell, for which I am grateful.

            [5]    Donald B. McIntyre, Language as an Intellectual Tool:
                  From Hieroglyphics to APL, IBM Systems Journal, Vol. 30,
                  Number 4 (1991) 554-581.

            [6]    Donald B. McIntyre, Hooks and Forks and the Teaching of
                  Elementary Arithmetic, Vector, Vol. 8, Number 3 (January
                  1992) 101-123.

            [7]    Donald B. McIntyre, Using J with External Data:  two
                  examples, Vector, Vol. 8, Number 4 (April 1992) 97-110.

            [8]    Kenneth E. Iverson, and E.E. McDonnell, Phrasal Forms,
                  APL89 Conference Proceedings, New York City, August
                  1989.   QuoteQuad, Volume 19, Number 4, (1989) p.197-
                  199.



                                       -13-





            [9]    Roger K.W. Hui, Kenneth E. Iverson, Eugene E. McDonnell,
                  Tacit Definition, APL91 Conference Proceedings,
                  Stanford, California, August 1991.   APL Quote Quad Vol.
                  21 Number 4 (August 1991), p.264-273.























































                                       -14-