I know that I can set keyboard shortcuts for F1–F12 with the PFKEY system function. But is there any way to set other shortcut keys in the Linux TTY IDE? (I've found instructions for the Windows GUI IDE and (more limited) instructions for RIDE, but I'm having trouble finding anything for the version I use.)
(From some references in the docs, I suspect that /opt/mdyalog/17.0/64/unicode/aplkeys/xterm might be related somehow, but I couldn't quite tell how that file works. Minor edits to it didn't seem to have a major effect, and I am reluctant to change it more without a better understanding.)
@ZhengqunKoo Sure, but how are you running the code? Also, you can do ⎕FIX'file://path/to/ns.dyalog' to "import" such a namespace. After that, you can just do ns.fnname
@ZhengqunKoo I don't quite get what the problem is with :Require. Doesn't ns.variable work?
So actually, it is easiest to grasp APL if you begin with the idea that it isn't just another programming language. Instead, look at it as an alternative mathematical notation where the inconsistencies and oddities of traditional mathematical notation (TMN) have been smoothed out, and various concepts (especially from linear algebra) have been generalised and harmonised.
Because it has been made regular and formalised, APL, as a mathematical notation, happens to be machine executable. However, it was actually originally meant as a notation for communication of mathematics between humans.
@frank So, e.g. you know how TMN (and Python etc.) have an order of evaluation; multiplication before addition, etc., right?
APL has a very rich symbolic vocabulary, and instead of keeping a large list of precedences, it uses one simple rule: All functions have long right scope.
So, all functions have the same precedence, we just execute from right to left.
@frank There are a couple of reasons why APL uses right-to-left and not left-to-right, which I can go into if it bothers you. Otherwise, we'll just continue.
OK, so in short, it generalises that f(x) and -x have their argument on their right, and it is also modelled after English which likewise is written and reads left-to-right, but actually parses from right to left: Reverse the old car — notice how each word applies to everything on its right until the end of the sentence.
Btw, APL uses proper mathematical symbols, not poor ASCII substitutes: × and ÷ are multiplication and division. There are many others: ∧∩ etc.
The most basic of APL's generalisations of TMN comes from the - symbol. Just like both a-b and -b have meaning, so to does APL allow all functions to have a dyadic (infix) meaning and a different (usually related) monadic (prefix) meaning.
In many cases the monadic form is identical to a dyadic call with a specific "default" left argument.
Yeah, so it isn't really the reciprocal magnitude, but you get the idea :-)
Let's talk about arrays.
In APL, all data resides in arrays. As opposed to Python (but in common with linear algebra, NumPy, and other mathematical libraries and programming languages), arrays can have any number of dimensions.
A single number, a scalar, has 0 dimensions. A vector has 1, and a matrix has 2, etc.
So in order to pinpoint which element of a list (i.e. a vector) we're talking about, we need exactly one index, while a matrix element needs two. A scalar does't need any indices, as there's only that one element.
In APL, you can write a vector simply juxtaposing the elements: 3 1 4 1 5 is the length-5 vector TMN would write as (3,1,4,1,5). The parenthesis and comma notation works fine in APL too, but is not necessary.
I was concatenating onto a long array just now with ,. Is it just my imagination, or is concatenating slower with a large array? I would have thought that appending to an array would be O(1)
@frank Another thing APL generalises is the concept of higher order functions, which we call operators. E.g. ∑ and ∏ of TMN are really specific instances of a general concept, namely reducing the number of dimensions by 1 using a function, addition or multiplication in these two cases.
@Adám Hmm, the code I had that seemed to be O(n) was of the form large_vector,←(⊂single_element). But it sounds like you are saying that should have been O(1)?
@codesections Another thing that can change concatenation from O(1) to O(n) is if the internal representation has to be changed. Was large_vector a simple vector before the concatenation? Clearly you are appending a nested element.
@frank / is a higher order function (remember that ÷ is division) which takes a dyadic function on its immediate left and derives a new function, this one monadic, which is the corresponding reduction (or fold). Hence, +/ is sum, and ×/ is product:
@Adám Well, the general form was to start with large_vector←⍬ and then use a recursive function to repeatedly apply large_vector,←(⊂single_element) (where single_element is a matrix of ints with ⍴ 3 4). I wouldn't think that involves changing the internal representation of large_vector, but maybe I'm confused?
@frank Here's another generalisation: the dot product of two vectors is really a conjunction of repeated multiplication followed by repeated multiplication. APL generalises this into a dot operator which takes two functions, one on the left and one on the right, and conjoins them in the same way as + and × are handled in the dot product. Thus, the classical dot product is +.×:
@codesections Right, if large_vector is already a vector of matrices, then it should be O(1), assuming there's enough free memory immediately following the current pocket. (We reserve extra space for such extensions, so there normally will be.)
@codesections in dyalog a,←b can be O(1) only if you're lucky enough that the memory right after a is free, in addition to the conditions already mentioned
@frank So these four are actually all the fundamental classes in APL: arrays, functions, monadic operators and dyadic operators. You know pretty much all of APL — syntactically speaking.
There's thing to note about operators: They bind their operands with long left scope, continuing until the end of the left-hand array or function phrase (but only one of those, never both). So, e.g. +.×.+ is (+.×).+ and +.×/ is (+.×)/
@frank Do you want more? E.g. how to do matrices etc.?
Right, and pretty much all built-ins deal seamlessly with arrays. Arithmetic ones map like this, various structural ones each have their own (sensible) rules. E.g. membership:
As you've probably noticed by now, APL doesn't have any reserved words. You're free to use pretty much any Western European identifier. Assignment is done using ←:
No problem. The first, and therefore leftmost, character is ⍺ while the last, rightmost, is ⍵. When we define lambdas (we call them dfns — /dee-funs/) we use these to indicate the left argument and the right argument:
With time, you'll think in APL instead. Another thing we generalise is that all functions are inline prefix or suffix. So where TMN uses position in 3², APL uses the * symbol:
@frank Challenge: using just the built-ins I've shown you, can you define a function Count which takes a numeric vector as argument, and returns its length?
Ah, bot technicalities again. Since we don't want it to react to everything people write, it only looks for messages that being with ⋄ and ⍞← and ⎕← (and a few other APL specifics).
OK, so let's introduce a new function denoted by Greek letter Rho, ⍴, which stands for reshape. It takes a shape on the left and content on the right, and returns an array of the requested shape, filled with the given content. If there isn't enough content, it recycles the content:
@frank Although, for convenience, we do provide a short notation, as 0-length lists are very commonly used: ⍬ It is a 0 overstruck with a tilde ~, the tilde symbolising "not" or "nothing".
Oh, cool. Well, in APL it is generalised such that ∘.× is the outer product (it is notationally similar to the dot product +.× except we don't do the final summation, so the ∘ signals a null-operation here). Effectively, a multiplication table:
