APL Wiki logo: Difference between revisions

From APL Wiki
Jump to navigation Jump to search
Miraheze>Adám Brudzewsky
(WIP)
 
Miraheze>Adám Brudzewsky
Line 52: Line 52:
1
1
</source>
</source>
And how about sets of five? Well, we only have for items, so there are no such sets:
A really nice feature of APL is its array-orientation. For computations which are defined on single elements, [[wikipedia:map (higher-order function)|map]]ping is implicit:
<source lang=apl>
<source lang=apl>
       5!4
       0 1 2 3 4!4
0
1 4 6 4 1
</source>
</source>
And how about picking out zero items? Since all empty hands are equal, there is exactly one such set — the empty set:
(What's up with picking zero out of four items? Since all empty hands are equal, there is exactly one such set — the empty set.)
== Order of evaluation ==
We want to generate the indices using <source lang=apl inline>⍳</source>…
<source lang=apl>      ⍳5!4

</source>
That didn't work! This is because APL dispenses with traditional mathematics' confusing and inconsistent precedence order<ref>K.E. Iverson, [https://www.jsoftware.com/papers/EvalOrder.htm Conventions Governing Order of Evaluation] (Appendix A of Elementary Functions: An Algorithmic Treatment). Science Research Associates, 1966</ref>, replacing it with a simple right-to-left rule:
<source lang=apl>
      (⍳5)!4
1 4 6 4 1
</source>
== Swapping arguments ==
If the arguments of <source lang=apl inline>!</source> were swapped, we didn't need that parenthesis. Enter the [[operator]] (higher-order function) [[swap]] (<source lang=apl inline>⍨</source>) which takes a [[dyadic]] function on its left and creates a new [[derived function]] which is identical to the original, but has swapped arguments:
<source lang=apl>
<source lang=apl>
       0!4
       4!⍨⍳5
1
1 4 6 4 1
</source>
</source>
This shows another tendency in APL; that to generalise common operations even to edge cases.
 
Now we can ask
== References ==
== References ==
<references />
<references />

Revision as of 01:14, 3 November 2019

APL Wiki logo

The APL Wiki logo can be seen as the following numeric matrix, where each number indicates the circle size. This page will explain, step-by-step, an expression[1] for this matrix — an expression which demonstrates quite a few APL features:

      ⎕IO←0
      ⌊∘.+⍨.5×4!⍨⍳5
1 2 3 2 1
2 4 5 4 2
3 5 6 5 3
2 4 5 4 2
1 2 3 2 1

We will follow APL's evaluation from right to left.

Counting from 0 or from 1

A computer console:

Whether to count from 0 or from 1 is an old disagreement among programmers. Many APLs let you choose whichever convention you want, but they tend to use 1 by default. To switch convention, we set the variable ⎕IO:

      ⎕IO←0

By the way, IO stands for Index Origin.

We can already now observe a couple of APL's characteristics:

  • The name ⎕IO begins with the special Quad character (a stylised console) which symbolises the computer system itself. APL has no reserved words. Rather, all built-in constants, variables, functions and operators have the prefix indicating that they are part of the system. Because of this, we call them quad names.
  • Assignment is not done with = like in many other programming languages, but rather with which also indicates the direction of the assignment: Whatever is on the right gets put into the name on the left.

Generating indices

The function takes a number N and generates indices until is has made N indices. Since we set ⎕IO to 0, we count from 0 until right before N:

      ⍳5
0 1 2 3 4

How many subsets?

Consider a bag with four distinct items. If you stick your hand into the bag and pick two items out, how many different possibilities are there for which pair you get out? . APL can tell you this with the ! function:

      2!4
6

Notice how APL uses traditional mathematical symbols in a generalised way. The traditional post-fix (after its argument) symbol is used with a syntax similar to how you'd normally use or Failed to parse (syntax error): {\displaystyle ×} . In fact, all APL functions can be used infix, like or prefix, like .

Anyway, how many sets of four could you pick? Obviously, only one; all the items:

      4!4
1

A really nice feature of APL is its array-orientation. For computations which are defined on single elements, mapping is implicit:

      0 1 2 3 4!4
1 4 6 4 1

(What's up with picking zero out of four items? Since all empty hands are equal, there is exactly one such set — the empty set.)

Order of evaluation

We want to generate the indices using

      ⍳5!4


That didn't work! This is because APL dispenses with traditional mathematics' confusing and inconsistent precedence order[2], replacing it with a simple right-to-left rule:

      (⍳5)!4
1 4 6 4 1

Swapping arguments

If the arguments of ! were swapped, we didn't need that parenthesis. Enter the operator (higher-order function) swap () which takes a dyadic function on its left and creates a new derived function which is identical to the original, but has swapped arguments:

      4!⍨⍳5
1 4 6 4 1

References

  1. "Bubbler", message "52389201" in The Nineteenth Byte chat room. Stack Exchange network, 2019-10-31 23:57
  2. K.E. Iverson, Conventions Governing Order of Evaluation (Appendix A of Elementary Functions: An Algorithmic Treatment). Science Research Associates, 1966