─────────────── Function Arrays ─────────────── Dyalog APL doesn't have arrays of functions but they can be simulated in various ways. Apart from →fnarray←, each of the operators here utilises a derived funct- ion "tree". The seemingly "linear" sequence ··· F op G op H ··· arg, can be rep- resented graphically in the following fashion: ┌─··· arg ┌─op─┐ ┌─op─┐ H ┌─op─┐ G ··· F The function array operators typically traverse the left "spine" of the tree by applying ⍺⍺ to an argument until the required operand is reached. →fnarray← uses an array of namespace references to contain each function. ------------------ Function selectors ------------------ Operators →case← and →of← apply the selected monadic function to the right argu- ment of the derived function. →case← uses a boolean "mask" and →of←, a "pick" index. There is a subtle but significant difference in the usage of →case← and →of←: 0 1 0 - case ! case + 3 ⍝ [larg] fn case fn case fn rarg 6 2 of - of ! of + 3 ⍝ [land] of fn of fn of fn rarg 6 [larg] is the left _argument_ of the derived function: (fn case fn case fn), whereas [land] is the left _operand_ of the leftmost →of← operator. In Dyalog, we can _name_ a derived function such as (fn case fn case fn) and with this example, sometime later use the name in conjunction with a left argu- ment to "pick" a function to apply to a right argument. However, we can't name an incomplete operator expression (of fn of fn of fn) which has a missing left operand. Operationally, →case← can "see" its left argument from the top (righmost) node of the derived function tree and pass an optionally modified copy of it left- wards to each lower level. An →of←-tree on the other hand, has no left argument and must traverse left until it happens upon an operand that isn't a function. Phil Last suggests a further operator [sel], which indexes _leftwards_ from the rightmost operand function: sel←{ ⍝ select function from RHS of list. ⍺≤⎕IO:⍵⍵ ⍵ ⍝ apply ⍵⍵ at selected level. (⍺-1)⍺⍺ ⍵ ⍝ traverse left. } This combines →of←'s simplicity in that a pick index is used, with the advantage of →case←, that the derived function may be named. But here's the rub: the left- most operand function must accept but ignore, a left argument. This is because the operator doesn't know it _is_ the leftmost function and so passes the next lowest index as left argument. This is not really a problem as an ambivalent function may easily be made strictly monadic by composing or enclosing it with a monadic identity function: ⊢∘fn or {fn ⍵}. fnlist←{⌈⍵} sel ⌊ sel - sel ÷ ⍝ 'vector' of functions, ⎕nc'fnlist' ⍝ ... is a derived function. 3 1 fnlist 2.5 ⍝ 1st from right function. 0.4 4 fnlist 2.5 ⍝ 4th from right function. 3 --------------------- Function distributors --------------------- Operators →lof← (list-of-functions) and →vof← (vector-of-functions) distribute their functions over or between their array arguments. The distinction between →lof← and →vof← is that in the former, each function is applied to the whole argument array, whereas in the latter, the items of the argument are distributed to each function. monadic: F lof G x y ←→ (F x y) (G x y) F vof G x y ←→ (F x ) (G y) dyadic: a b F lof G x y ←→ (a b F x y) (a b G x y) a b F vof G x y ←→ (a F x ) ( b G y) Examples: 1 5 3 + lof ⌈ lof ⌊ lof | 6 2 4 7 7 7 6 5 4 1 2 3 0 2 1 1 5 3 + vof ⌈ vof ⌊ vof | 6 2 4 6 2 1 - lof ÷ lof ! 4 5 6 ¯4 ¯5 ¯6 0.25 0.2 0.1666666667 24 120 720 - vof ÷ vof ! 4 5 6 ¯4 0.2 720 See also: case of lof vof for fnarray Back to: contents Back to: Workspaces