# Stories/RichardBrown

` `Appendix A: A Functional Program Summary

` `Appendix B: A 'Higher Level' Functional Version

` `Appendix C: J Program in Imperative Style

` `Appendix D: Primitive J Functions Used

## What is Functional Programming?

Functional programming is a style of computer programming which, in its purest form,
involves only functions. (For a short survey article on functional programming
see the August 1994 issue of *Byte*.) If` x `represents the input data of the program,
then the goal is to design a function` f `such that` y = f(x) `is the desired output.
Thus a program is a function. The function` f `is built by combining various
primitive functions that are provided by the functional programming language.
This approach to programming is quite different from the conventional approach
(exemplified by assembly language, FORTRAN, Pascal, C, etc.) which may be called
imperative programming because a program is a list of commands.
In imperative programming, data is stored in memory cells with symbolic addresses
and a list of commands is executed in order, usually with some branching or looping.
This conventional approach is really a sugaring of machine language for
a von Neumann type of computer architecture with stored program, stored data,
and step-at-a-time execution of commands. The functional approach
is machine independent: functional programs do not have to be rewritten for
a different architecture, say, for a parallel machine.

## What is J?

J is a programming language developed from A Programming Language (APL)
by Ken Iverson (father of APL) and Roger Hui. Unlike APL which uses a
special character set, J uses only the ASCII characters. Primitive functions
are denoted by single characters like` + `or by following such characters
with a period or colon as in` +. `or` +:` .` `Like APL, J has primitive functions for operating on arrays without using indexes or looping. For example, if` A `and` B `are two matrices of the same shape then` A+B `computes the elementwise
sum of` A `and` B` ,` `and` >./A `computes the list of greatest elements of the
columns of` A` .

## Why Use J for Functional Programming?

There are many reasons. J has a vast collection of primitive functions to
call upon and these extend to arrays easily. More importantly, J has a variety
of ways of combining functions that go beyond the usual composition of functions.
One of the most important combinations is called the *fork*. If` f `and` g `are
monadic functions and` h `is dyadic then` f h g `is a monadic function and
its meaning is as follows:` (f h g)(x) = f(x) h g(x)` .` `This construction
is familiar in mathematics where, for example, the sum of two functions` f+g `is
a function whose value on an argument` x `is defined to be` f(x)+g(x)` .` `A
standard example of a fork from the J tutorials illustrates the idea.
Suppose that` x `is a list of numbers and we want` y = a(x) `to be the
arithmetic mean. We write

sum =: +/

(read as 'plus over', see Appendix D for a dictionary of all the J primitive functions used in this article) and then the fork

a =: sum % #

(which reads as 'sum divided by number') is the desired arithmetic mean function.

The assignment statements used in the sentence above are assignments of
names to functions (or programs or verbs as they are called in J).
No use has been made of assignments of names to data (nouns in J).
Moreover, the assignments made above are permanent names.
Let us contrast this with the traditional approach.
If you write the code for arithmetic mean in a conventional language,
you will write a sequence of commands with assignment statements of data
to named memory cells (variables).
The sequence of statements will have control structures that produce loops.
Some variables will refer to memory cells whose contents change
each time you go around a loop. Thus variables are transient things
that are used in the program but have no permanent meaning.
(In functional programming, an assignment of the form` x =: x+1 `makes no sense!
In imperative programming such statements are commonplace!)

In J, a *dyadic fork* is also defined. This definition is more general
than normal mathematical notation or the kind of compositions defined
in other functional programming languages. The fork` +*- `is defined
as follows:` x(+*-)y `means` (x+y)*(x-y)` .` `We will
use the dyadic fork extensively below.

A sequence of three verbs is a fork.
A sequence of two verbs in J is called a *hook*.
The first verb must be dyadic and the second monadic.
For example,` x(+%)y `means` x + 1/y `and` (+%)y `means` y + 1/y` .` `Thus
we can read the hook` +% `as 'plus reciprocal'.

## What is Operations Research?

Most problems in operations research involve optimizing
an objective subject to constraints. Typical examples are maximizing
profit subject to resource constraints or minimizing shipping costs
subject to the constraints of a transportation system.
One of the most common types of problems has a linear objective function and linear constraints and such problems define a subject called linear programming.
(This is a quite different use of the word 'programming'!)
Here is a very small example.
(We use J-notation:` <: `means 'less than or equal'
and` >: `means 'greater than or equal'.)

- maximize
`z = 2x + 3y`

subject to`4x + y <: 12`and`2x + 5y <: 15`

with`x >: 0`and`y >: 0`.

- maximize

The *simplex* method was developed by G. Dantzig in the 1950's and
has been the standard method for solving linear programming problems since then.
Only recently has the simplex method been challenged by other methods
and only in large problems with thousands of variables and constraints.
To apply the simplex method, we convert the inequalities to equalities using slack
variables:` 4x + y + s = 12 `and` 2x + 5y + t = 15 `with` s >: 0 `and` t >: 0` .` `We
write our problem as a system of linear equations:

z - 2x - 3y = 0 4x + y + s = 12 2x + 5y + t = 15

and study various feasible (i.e. non-negative) solutions of this system.
Notice that the system is 'solved' for the variables` z` ,` s` ,` `and` t `in
terms of` x `and` y` .` `We can set` x = 0 `and` y = 0 `and we get three equations
in three unknowns with solution` z = 0` ,` s = 12` ,` t = 15` .` `This solution
is feasible because all variables are non negative;
but this solution does not have a very good value of` z` .` `In
the simplex method, we move from solution to solution in such a way
that` z `increases with each move until no further increase is possible.

If we divide an equation by a nonzero constant or if we add a multiple of one equation to another equation, then we get a new system of equations that is equivalent to the old system. On the computer, we do these operations on the matrix of coefficients. We divide a row by a constant and add multiples of a row to other rows.

Below we show the original coefficient matrix
and beside it we show the result of dividing the bottom row by 5 and
then adding multiples of the new bottom row to the rows above to create zeros
in the rest of the` y`-column.

z x y s t z x y s t 1 _2 _3 0 0 0 1 _0.8 0 0 0.6 9 0 4 1 1 0 12 --> 0 3.6 0 1 _0.2 9 0 2 5 0 1 15 0 0.4 1 0 0.2 3

This represents a system of equations

z - 0.8x + 0.6t = 9 3.6x + s - 0.2t = 9 0.4x + y + 0.2t = 3

which is solved for` z` ,` y` ,` `and` s` .` `If we set` x = 0 `and` t = 0 `we
get the feasible solution` z = 9` ,` s = 9` ,` `and` y = 3` .` `The
row operations above are called a 'pivot' for geometric reasons
(the feasible set has been pivoted around so that a new point of it is at the origin.)
It turns out that if we do another pivot that converts the 3.6 to 1 and
clears the rest of the x column then we get a new solution
with` x = 2.5` ,` y = 2` ,` z = 11` .` `Moreover, this turns
out to be the optimal solution.

The simplex method can be divided into two parts: (1) finding the location of the pivot (including testing for optimality and unboundedness) and (2) the pivot operation itself.

## Pivoting in J

Let` M `denote the original matrix of coefficients above. Let` R `denote
the pivot row,` R =: 0 2 5 0 1 15` ,` `let` P `denote
the pivot,` P =: 5 `and let` C `denote the pivot column,` C =: _3 1 5` .` `Then
the row operations making up the pivot can be summarized in one J expression:

M - (C-B)*/(R%P)

where` B =: 0 0 1` .` `This formula says that the pivoted matrix is
the original matrix` M `minus various multiples (the multiples are in the
expression` C-B`) of the row` R `divided by the pivot` P` .` `The` B `term
is necessary because the third row is treated differently from the
other rows and without the` B `term, the pivot row would become a row of zeros.
Given this formula, it is clear how to write J code in non-functional
style for doing the pivot.
(See Appendix C for the simplex method written in J using a traditional approach.) But we will show how to use a purely functional approach based
on the use of dyadic forks.

We will define a function` pat `('pivot at') that would be used as
follows to do the above pivot:

M pat 3 3

meaning '`M `pivot at row 3 and column 3'. Note that we are indexing rows from 1 to 3 and columns from 1 to 6 (not 0 to 2 and 0 to 5 as is normally done in J). This means that our functions must convert back and forth between indexing with origin 1 and J indexing with origin 0.

According to APPENDIX D, the dyadic verb` [ `gives its left argument.
Therefore the definition of` pat `is the dyadic fork

pat =: [ - ext

where` ext `is the dyadic function such that` M ext 3 3 `computes` (C-B)*/(R%P)` .` `If
we now use` mc `and` mr `('modified column' and 'modified row') for the dyadic
functions computing` (C-B) `and` (R%P) `then the definition of` ext `is the fork

ext =: mc */ mr

and it remains to define mc and mr. Assume we have defined dyadic
functions` xc `and` xr `and` xe `('extract column', 'extract row', 'extract element')
that work as follows.` M xr 2 3 `extracts the second row of` M `(ignoring the
column index)` M xc 2 3 `extracts the third column of` M `(ignoring the row index)
and` M xe 2 3 `extracts the element in the second row and third column.
Also suppose bv is a dyadic function such that M bv 2 3 is 0 1 0
(a basis vector with a 1 in the second position, ignoring the column index 3).
Then` mc `and` mr `can be defined as forks

mc =: xc - bv mr =: xr % xe

Now we define` xc` ,` xr `and` xe` .` `Recall that we are referring to the first row
as row 1 not as row 0. Each verb is a fork with central verb 'from' (which is` { `in J,
see Appendix D). The right verb is` [ `which means 'left argument'.
The left verb is a composition (using` @`) of several verbs. The monadic verb` <: `is 'decrement' and is used to change to J indexing. Refer to Appendix D
for other verbs.

xr =: (<:@{.@]) { [ xc =: (<:@{:@]) {"1 [ xe =: (<@:<:@]) { [

Actually we could make shorter definitions using hook instead of
fork and using commute` ~ `to swap the arguments of` {` .

xr =: {~ <:@{. xc =: {~"1 <:@{: xe =: {~ <@:<:

Finally, we define` bv` .` `We use a fork with central verb equals.
The left verb takes the left argument, finds the number of items
(rows)` m` ,` `and then creates an index set` 1 2 ... m` .` `The
right verb takes the right argument,
takes the first entry (which is the pivot row index) and decrements it.
Under equals, the result is a vector of 0's and a single 1 where the index
equals the pivot row index.

bv =: (i.@#@[) = (<:@{.@])

This completes the definition of pat. It can be tested as shown in the examples below.

## The Simplex Method in J

It remains to specify where to pivot and when to stop pivoting. The pivot column is selected as that column (excluding the last column) whose first row has the most negative entry. In the example above, starting with the solution x=0, y=0, z=0, s=12, t=15 one sees that z=2x+3y can be improved by increasing either x or y; but an increase in y is better. So the y column is selected as the pivot column. In the matrix, this choice corresponds to selecting the most negative element in the top row. If none of these entries is negative then no improvement in z is possible so no further pivot is required and the optimal solution has been found. Once the pivot column has been selected, we need to know how large to make the variable (y in the example) that is being increased. Each constraint (that is, each row of the matrix below the first row) sets a limit on the size of the variable being increased. The limit can be computed as a quotient with numerator from the right border and denominator from the pivot column.

For example, the first constraint gives the limit y <: 12/1 and the second constraint gives the limit y <: 15/5. All such constraints must be satisfied. If the smallest is satisfied then all will be satisfied; hence the pivot row is selected to minimize the quotients. However, there is a catch: if the denominator is zero or negative then the constraint should be ignored.

In teaching the simplex method, one finds that students have no problem doing the simple calculations that find the pivot column and the pivot row as outlined in the previous paragraph. But the pivot operation involves tedious arithmetic. Hence it is convenient for students, who are learning about the simplex method, to find the pivot manually and then use the function pat defined above to do the pivot.

It is, perhaps, surprising that although finding the pivot is a trivial part of the simplex method when done by hand, the computer code for finding the pivot is rather tricky!

First we need a function to find the location of the minimum element in a list. Least is 'lesser over' and is therefore <./ The hook below can be read as 'index of least'

ml =: i. <./

Now we can write the function pc that finds the pivot column. We take the first row, drop the last element, and find the minimum location. Then we increment this index so the first row has index 1 (not 0) as mentioned above. This can be accomplished as a composition (using @) of ml with primitive functions:

pc =: >: @ ml @}: @ {.

However, this is not good enough! Recall that we also want to detect an optimal matrix so we can tell the simplex method when to stop. Therefore, we adopt a somewhat different approach. We take the first row, drop the last element, append a leading zero, and apply ml. If the row has a negative element then ml will find the location of the most negative element and, because of the leading zero, that index will already be incremented into the range 1 to n. If there is no negative element in the top row, then ml will find the appended leading zero at location 0 and pc will return a zero result. This can be used to detect optimality.

pc =: ml @ (0&,) @ }: @ {. opt =: 0&= @ ]

To find the pivot row we need a new version of division. We want ordinary division, else, if the denominator is not positive, infinity. When such 'quotients' are searched by ml for the location of the minimum, those whose denominators are not positive will be ignored. In the code below, the function inf is a constant function with value infinity. The function dnp ('denominator not positive') is 1 if the denominator is not positive and 0 otherwise. The new division operation is dp which stands for 'divide positive'.

else =: ` if =: @. inf =: _: @ [ dnp =: 0&>: @ ]"0 dp =: % else inf if dnp

We can now find the pivot row with the dyadic function pr whose left argument is the matrix and whose right argument is the index of the pivot column.

pr =: >: @ml @ ((xc 0:) dp xc)

(The dirty trick in the above line is this: The hook (xc 0:) appears to extract column zero but actually extracts the LAST column to be used as the list of numerators! This is because xc includes a decrement function that reduces the 0 to -1. In J the index -1 means last.)

Note that the function` pr `works on the entire columns
including the first row. The first row is not a constraint
and should be ignored. But the first row will always give an infinite
'quotient' under` dp `and so will be ignored by` ml `as desired.

What happens if ALL 'quotients' are infinite? In that case there
is no limit on the size of the variable being increased and
the objective function is UNBOUNDED. This situation can be detected
by the condition that` pr `selects the first row and
produces the result 1. The function` unb `detects an unbounded problem.

unb =: 1&= @ {. @ ]

We create a function` cpat `('conditional pivot at')
which is 'pivot at else infinity if the problem is unbounded'.

cpat =: pat else inf if unb

Now we create a function pin ('pivot in') such that M pin 2 means 'M pivot in column 2'. The pivot row is found automatically by pr.

pin =: [ cpat pr,]

This train of five dyadic verbs is parsed by J as [ cpat (pr,]) which is a fork in which the third verb is itself a fork.

We can now define either a recursive or iterative version of the simplex method. The recursive version is 'simplex':

simplex =: (simplex @ pin else [ if opt) pc

For the iterative version, we define 'conditional pivot in' and 'pivot'

cpin =: pin else [ if opt pivot =: cpin pc

Finally, the 'smplx' function iterates the 'pivot' function 'to infinity'! This means the matrix is pivoted until the same matrix occurs twice in succession (and hence no further change will occur). The result will be either the optimal matrix or infinity if the problem is unbounded.

smplx =: pivot^:_

NOTE: As one might expect, there are many ways to write the simplex method in J using a functional programming style. For a different approach, see Appendix B.

## Examples

To solve the small problem posed above, we define the matrix

M=:1 _2 _3 0 0 0 0 4 1 1 0 12 0 2 5 0 1 15 M=:3 6$M M 1 _2 _3 0 0 0 0 4 1 1 0 12 0 2 5 0 1 15

Then we apply either of the functions smplx or simplex

smplx M 1 0 0 0.222222 0.555556 11 0 1 0 0.277778 _0.055556 2.5 0 0 1 _0.111111 0.222222 2

and get the optimal matrix. As a system of equations, this is

z + 0.22s + 0.55t = 11 x + 0.27s - 0.55t = 2.5 y - 0.11s + 0.22t = 2

and it tells us that the optimal solution is x = 2.5, y = 2, and z = 11. (And s = 0 and t = 0.)

One advantage of the functional approach is that we have developed a collection of useful functions along the way. These can be tested separately or used to show students the steps of the simplex method. For example

pc M NB. Finds pivot column. 3 M pr 3 NB. Pivot row in third column. 3 M1 =: M pat 3 3 NB. Pivots at 3, 3. M1 1 _0.8 0 0 0.6 9 0 3.6 0 1 _0.2 9 0 0.4 1 0 0.2 3 pc M1 2 M1 pr 2 2 M1 pat 2 2 1 0 0 0.222222 0.555556 11 0 1 0 0.277778 _0.055556 2.5 0 0 1 _0.111111 0.222222 2

### APPENDIX A: Functional Program Summary

pat =: [ - ext ext =: mc */ mr mr =: xr % xe mc =: xc - bv xr =: {~ <:@{. xc =: {~"1 <:@{: xe =: {~ <@:<: bv =: (i.@#@:[) = (<:@{.@]) ml =: i. <./ pc =: ml@(0&,)@}:@{. if =: @. else =: ` inf =: _:@[ dnp =: 0&>:@]"0 dp =: % else inf if dnp pr =: >:@ml@((xc 0:) dp xc) unb =: 1&=@{.@] cpat =: pat else inf if unb pin =: [ cpat pr,] opt =: 0&= @ ] simplex =: (simplex@pin else [ if opt) pc cpin =: pin else [ if opt pivot =: cpin pc smplx =: pivot^:_

Note that it may be desirable to use J's fix adverb to 'compile' some of these functions into compositions of primitives. For example we can write

pat =: pat f.

and then we find that instead of the original definition above, pat is now defined as

[-(({~"1<:@{:)-(i.@#@[=<:@{.@]))*/(({~<:@{.)%({~<@<:))

The new 'compiled' version runs a bit faster than the original. Moreover, we could now erase some of the functions that were used to define pat if we have no need for these functions and don't want them cluttering up the symbol table.

erase =: (4!:55)@;: erase 'ext mr mc xr xe bv' 1 1 1 1 1 1

(The output of 1's shows that all six items were erased.)

### APPENDIX B: A 'Higher Level' Functional Version

Here is a different approach to the simplex method. First we assume the pivot is in the first row and first column. That allows us to define a monadic function piv such that piv M will do the pivot operation on M. Moreover, we will give a new way of doing this pivot. We handle the first row first (by just dividing it by its first element) and then do the lower rows using a */ product.

fr =: {.%{.@{. lr =: }.-(({."1@}.)*/{.) piv =: ({.,lr)@(fr,}.)

The dyadic function row is used as in M row 4 which takes the first 4 rows of M and reverses their order, thereby bringing the 4th row to the top. (Of course M row 4 applied again will restore M to its original form.)

row =: ((|.@{.),}.)~

Similarly, col does the same for columns.

col =: row"1

Now we define a conjunction at so that M piv at row 4 will bring row 4 to the top, do the pivot and then put row 4 back where it belongs.

at =: ((@:`].)`])(`:6)

(At the end of this appendix is an explanation of at.)

We define a function pr that finds the pivot row of a matrix assuming that the pivot column is the first column. For that, we use the functions if, else, dnp, dp, ml defined in the main article above.

pr =: >:@ml@:(({:"1)dp({."1))

We also use the same functions inf, unb, opt, and pc. Then we put it all together as follows:

pin =: (piv at row else inf if unb pr) at col simplex =: (simplex@pin else [ if opt) pc

This code is more sophisticated than that of the main article because it uses a defined conjunction at which is a higher level function (its arguments are functions).

To describe the conjunction at, it is best to introduce the explicit method of defining functions. In J one may define functions in two ways: tacitly or using explicit variables as parameters. We have used the tacit method in this article. For example, consider the dyadic function x f y which computes 1+x+y. We could define this tacitly by f =: >:@+ or by f =: (1&+)@+ or by the fork f =: 1: + +. Or we could define it explicitly using J's locally constrained left and right parameters x. and y. (more recently denoted simply as x and y) by

f =: 3 : '1+x.+y.'

(Here the '3' tells J to make a verb. For a conjunction, use '2', for an adverb use '1' and for a noun use '0'.) In this case, the function f will be stored by J in the explicit form given and when called, as in 5 f 6, the values 5 and 6 will be substituted for x. and y. respectively. It is also possible to ask J to convert an explicit form to a tacit form. To do this, we use '13' instead of '3'. Thus

f =: 13 : '1+x.+y.'

causes J to produce the tacit verb f =: 1: + + .

In our case, we want to create a conjunction at that applies its right argument (some verb, in our case row or col) first, then applies its left argument (some other verb, in our case piv) and then applies its right argument again. (Note: This is similar to, but not exactly the same as, the J primitive conjunction &. .) Thus we can define at explicitly by writing

at =: 2 : '(x.@:y.)y.]'

When given an instance like M piv at row 4 the conjunction at forms a fork (piv@:row)row] which combines with the arguments M and 4 to give (piv (M row 4)) row 4 which is just what we want.

If, instead of the above, we ask J to create a tacit version by writing

at =: 13 : '(x.@:y.)y.]'

then J produces the tacit definition at =: ((@:`].)`])(`:6) given above. However, to program this tacit conjunction directly (or even to untangle its curious grammar!) one must go into much more detail on J than is appropriate in this short article.`

### APPENDIX C: J Program in Imperative Style

Here is the simplex method written in the traditional non-functional way - except that we define two functions at the start! This illustrates the fact that one may combine the functional programming style and the imperative programming style as one sees fit to create an efficient and readable program.

all =: *./ ml =: i.<./ simplex =: 3 : 0 M =. y. obj =. }:{.M if. all obj >: 0 do. M else. m =. #M pc =. ml obj C =. pc{"1 M den =. }.C if. all den <: 0 do. _ else. pos =. den > 0 num =. }.{:"1 M quo =. (pos#num)%(pos#den) r =. (ml quo) { pos#}.i.m R =. r{M P =. r{C simplex M-(C-r=i.m)*/(R%P) end. end. )

### APPENDIX D: Primitive J Functions Used

Here are the J primitive functions that were used above. For arithmetic we used the four basic operations of addition, subtraction, multiplication, and division.

2+3 2-3 2*3 2%3 5 _1 6 0.66666666667

Note that the negative sign, which is part of a negative number,
is the underbar. An underbar by itself is the 'number' positive
infinity and negative infinity is` __` .` `Also
note that division is` % `not` /` .

1+_ 1%0 _1%0 _ _ __

Primitive verbs in J are denoted by single characters like + or by such a character followed by a period or colon like +. or +: . Most primitive function symbols in J have separate monadic and dyadic meanings. For example, the monadic meaning of % is reciprocal. The monadic meaning of <. is 'floor' and the dyadic meaning is 'lesser' (i.e. 'min').

%2 <. 2.56 3 <. 2 2 <. 3 0.5 2 2 2

The obvious analogue statements are true about >. .

The monadic meaning of <: is 'decrement' and the dyadic meaning is 'less than or equals'.

<: 2.56 2 <: 3 3 <: 2 1.56 1 0

There are monadic and dyadic constant functions and monadic and dyadic identity functions:

0: 2 2 0: 3 ] 3 2] 3 0 0 3 3

(But note that 2[3 is 2 because [ is the identity function of its left argument, ignoring the right.) Constant functions 0: to 9: are defined; to make more general constant functions, the conjunction " may be used.

Thus 10"0 is a constant function that has value 10 on 0-cells. Applied to a matrix, it gives a matrix of 10's. Or 10"1 has value 10 on arguments of rank 1. Applied to a matrix it gives a 10 for each row of the matrix. And 10"_ applied to a matrix gives the number 10.

We used both the monadic and the dyadic versions of the adverb / . The monadic version applies its left argument (a dyadic verb) between the items of its right argument.

2+3+4 +/ 2 3 4 */ 2 3 4 <./ 7 3 9 6 9 9 24 3

The dyadic version gives a 'multiplication table' for the verb to the left.

2 3 4 */ 7 8 9 14 16 18 21 24 27 28 32 36

The & symbol is a conjunction. One common use of it is to combine a dyadic verb with an argument to make a monadic verb.

f =: 7&+ g =: %&4 f 2 3 4 g 2 3 4 9 10 11 0.5 0.75 1

Composition of functions is represented by @ .

f g 2 3 4 (f@g) 2 3 4 7+(5+6) 5(f@+) 6 7.5 7.75 8 7.5 7.75 8 18 18

For working with arrays (vectors, matrices and higher arrays) the following operations are available.

0 2 _1 { 8 3 4 7 {. 8 3 4 7 {: 8 3 4 7 8 4 7 8 7 }. 8 3 4 7 }: 8 3 4 7 2 {. 8 3 4 7 3 4 7 8 3 4 8 3 2 }. 8 3 4 7 i. 8 8 3 4 7 i. 4 4 7 0 1 2 3 4 5 6 7 2 $8 3 4 7 #8 3 4 7 M =: 2 2$8 3 4 7 4 4 M $M #M 8 3 2 2 2 4 7

The last two functions show that M has the shape of a two by two matrix and that M has two items (each item is a row).

The conjunction " is used to specify how a verb will act on an array. A matrix is a 2-cell, each of its rows is a 1-cell, and its elements are 0-cells.

9,M 9(,"2)M 9(,"1)M 9(,"0)M 9 9 9 9 9 8 3 9 8 8 3 8 3 9 4 7 9 3 4 7 4 7 9 4 9 7

The power conjunction ^: is used to iterate a function.

(f^:3) 3 7+7+7+3 (g^:3) 16 (g^:_) 16 24 24 0.25 0

If an iteration gives the same result as the previous case (to within a small tolerance) then the iteration stops. Therefore limits of iterations can be programmed by simply using the infinite power.

Gerunds are arrays of verbs that can be handled like nouns and then used as verbs. For example

ger =: f`g

is a gerund with components` f `and` g` .` `On the one hand we can
treat it like a noun by selecting its components or by shaping it into a matrix, etc.
On the other hand we can evoke it as a verb in a variety of ways.
One way is through the use of` @. `which is called 'agenda'.
The expression` f`g@.v x `applies the verb` v `to the argument` x `to
get a result` v(x) `which should be an integer,
in this case either 0 or 1. The index` v(x) `is used to
select` f `or` g `to act on` x` .
Thus the final answer will be` f(x) `if` v(x) `is 0 or` g(x) `if` v(x) `is 1.
In effect, we get the result` f(x) `else` g(x) `if` v(x)=1` .` `Thus
we make the code` h=:f`g@.v `more readable by defining

else =: ` if =: @. h =: f else g if v

By Richard L.W. Brown, York University.
Substantially the same text previously appeared as *Functional Programming in J for
Operations Research*
in Vector, Volume 11, Number 4, April 1995.