OK, so being that you are used to C and Python, let's start by discarding the notion that APL is a programming language (yes, despite the name), and instead look at it as an alternative (and better than the traditional) mathematical notation. It just happens to be rigorous enough to be machine executable, as opposed to the traditional mathematical notation (TMN).
APL was created by a mathematician (who was very fond of matrices and linear algebra) and so it borrows the most basic syntax and vocabulary from TMN.
@DudeMan True, but there are many simple solutions to that. For now, I suggest you use this.
Continuing with the - symbol in TMN: It can be used in an infix manner (between two arguments) and also (with a different but related meaning) in a prefix manner (to the left of a single argument), so too can and must all APL functions be used in one or both of these manners. This is a universal rule.
Now, one could look at the prefix - as being just like the infix - but with a default left argument of 0. Many APL functions have this kind of relationship between their monadic (that's what we call the prefix form) and the dyadic (the infix form) definitions. Another example of this in TMN is √ which has an implicit "2" on its left when used without a number on the left.
Now, can you guess what the "default left argument" of ÷ is?
@DudeMan That would be an option, but it wouldn't be very useful, as 0 divided by anything (except possibly 0) gives 0. It'd be a constant function. Any other ideas?
Now, for a little about arrays. Since you're familiar with C, you know that arrays can be seen as multi-dimensional collections where you can index each dimension separately. (Under the covers, this translates to a shape-radix conversion to a linear index into the flat data.)
In APL, the basic (and in fact only) form of data is the orthogonal array. Every array has a shape which is a list of all the lengths along all the axes.
It follows from this that a single atomic value (a scalar), which doesn't have any axes, is an array with 0 dimensions, and so its shape is the empty list.
So vectors (1D arrays) consist of 0 or more scalars (0D arrays) and matrices consist of 0 or more vectors, and 3D blocks of data consist 0 or more of matrices, etc. etc.
In general, you can expect APL to be very consistent in its treatment of data, and if you write nice code, it is likely to automatically work on higher dimensions.
I should have given a practical example. A 3 row 4 column matrix has the shape [3,4] and the list [2,7,1] has the shape [3], and the number 42 has the shape [].
Internally, every array is stored as its rank (number of dimensions) followed by its shape followed by the flat data.
So 42 is stored as 0,0 0 0 0 0 0 0 0 0 0 0 0 0 0 0,42
APL likes to keep things clean, with as little visual noise as possible. While a number is a number (we'll get back to that), you can create a list (vector) simply by putting elements next to each other.
So while I wrote Python/JSON before for the list [2,7,1], in APL you'd simply write 2 7 1.
Sure, but it is practical to reserve a fixed number of bytes for the shape, so the actual data always begins with the same offset relative to the beginning of the pocket.
Having used C and Python, there's a good chance you've written a loop or two in the past. APL tends to do that for you, so you can add two vectors with 3 1 4 + 2 7 1 and get 5 8 5
Traditionally, APL is used in a REPL, where the prompt is six spaces and the results are flush left, so I'll show examples like this:
3 1 4 + 2 7 1
5 8 5
@DenizGenç Welcome. Interested in APL?
So + adds the corresponding elements from its left and right arguments.
Exactly. However, the symbols ∑ and ∏ are not very suggestive of their relationships to + and × (other than being the Greek equivalent of the English initials of the words Sum and Product — pretty far out, if you ask me).
APL uses a simple general notation which also avoids having to write all kinds of stuff below and above the big symbol: +/ is sum and ×/ is product.
You can read that as plus reduce or plus over the elements of.
APL has a lot of built-in functions, and as you can write your own functions too, it'd be impossible to maintain a hierarchy for the order of operations.
Instead, APL generalises the rule that a monadic function takes its argument on its right: All functions take everything on their right as their right argument.
Think of it like this: You're used to seeing f(g(h(x))). Simply remove the parentheses: f g h x.
As you can see, it is quite natural for the rightmost function to be applied first, then working the way to the left.
It is extremely common to need the natural numbers, i.e. the integers. For that, APL uses a monadic Greek iota (like letter I as in Integers) symbol ⍳:
⍳10
1 2 3 4 5 6 7 8 9 10
Exercise: Write an APL expression that computes the sum of the first 100 integers.
@DudeMan I first got really interested in APL from this short, 8 minute video that piece-by-piece writes the Game of Life in APL! If you'd like to see what it looks like when APL is used to solve 'real' problems, I highly recommend it for a quick taste :) Game of Life in APL (REPL) in just 8 minutes
@Adám Would be super useful to be able to do that, as I currently use dzaima's pastebin, which doesn't allow further execution/experimentation! How did you link to TryAPL with specific stuff already inside?
@DudeMan Also, if the video intrigues you, TryAPL will walk you through creating the Game of Life the same way, with explanations at each step. That way you can experiment and play with what's happening as you build it up! (Navigate to "Learn">"Interesting Explorations" ) Game of Life Walkthrough in APL, Experiment in REPL
@Adám in this video @AviF.S. linked, the person doing the screencast goes through quite some trouble only to reproduce the behaviour of ({+/+⌿⍵}⌺3 3) ; how recent is ⌺??
@AviF.S. Just enter what you want, then hover over the input expression to reveal the permalink icon. Copy the link location or click it to open a new window.
re: stencil usage - using ⌺ isn't the same as doing all those rotations the person in the video does; as he mentions, he is implementing GoL in a torus and using ⌺ implements it in a restrict rectangle
@RGS Ah good point! Though I still expect it was before ⌺ was implemented! Plus, the torus part seemed like an afterthought/note about how he implemented it!
Not like he was writing the code to purposefully do it on a torus, just the way the code he wrote turned out
@RGS We're currently discussing extending ⌺ to be able to specify edge handling. While various image processing libraries mention all sorts of methods, I've not found anyone who gave them a systematic treatment. However, I came up with a classification system I think is pretty neat.
No, the edges are just before the 1st and just after the last element.
Now there are five basic ways to deal with the edge which I call (since "the community" doesn't have a standard nomenclature): Zero, Replicate, Reverse, Mirror, Wrap
Zero pads with 0s (or the appropriate fill) forever:
0 0|1 2 3 4 5|0 0
Replicate keeps going with the first/last element:
1 1|1 2 3 4 5|5 5
Reverse runs the original data in reverse on the other side of the edge:
So my idea for extending ⌺ is to give it a left argument with n element according to this system, just like it currently takes an n column vector or matrix as right operand which determines the cell size and optionally step size.
@Adám the only reason why I don't like this ¯1 is the following:
when you cross an edge, from that point onward you only find elements that were next to the edge and this happens if you go from centre to left or centre up
@RGS Yes, but actually, it is a bit more complex than that when it comes to ⌺ because it allows omitting trailing axes, and then it doesn't move in that dimension:
Currently, we feed a left argument to the left operand which is an appropriate left argument to ↓ to discard the added padding along each padded dimension. However, there is no left argument to ↓ which simultaneously drops from both left and right side.
Often, you don't even use the left argument, so it seems a bit silly to have to pad and chop (and the computation of how much to pad is non-trivial) if it is only to enable ⌺ to generate a left argument you won't use.
So my idea is that the dyadic form instead gives a left argument which is a vector of masks, one per dimension, with 1s for original data.
Alternatively, we could detect the cases where we can't give a left argument, and then not error, until the left argument is requested, at which point we VALUE ERROR.
Each possibility has upsides and downsides.
The vector of masks is more versatile, but unfortunately, ⌿ doesn't allow a vector of masks to be applied along a number of leading dimensions, though it could be extended to accept this.
Going for the VALUE ERROR allows putting the edge spec into the right operand, which is more consistent, and frees the left argument to specify something else. What might that be?
One thing that is pretty annoying is trying to use ⌺ to chop a matrix into a block matrix.
@RGS Here's a challenge for you: Given a matrix with sides divisible by three, chop it into 3-by-3 submatrices. E.g.
that's just me picking the correct submatrices out of the whole stencil, the 3 4⍴ and the (1 4 7 ∘., 1 4 7 10) depend on the input matrix obv
@Adám I don't get this; you are talking about the left argument that goes into the left operand, correct? why don't you give it a boolean array with the same shape as the right argument, with 1s in positions that correspond to original data?
(to randomly pop in, my opinion on ⌺ is for it to not do any padding for the borders, leaving that to the user, which should be trivial in most cases. Not an option for Dyalog, but if i get to it, that's how i'd implement mine)
BlockUp ← {
⍝ Takes an array as right argument and a vector as left argument.
⍝ ⍺ must have as many elements as ⍵ has dimensions.
⍝ Splits ⍵ in sub-arrays of lengths given by ⍺.
⍝ Assumes i⊃⍺ divides i⊃⍴⍵
w ← ⍵↑⍨ -(⍴⍵)+2×⌈2÷⍨¯1+⍺
1 1↓({⊂⍵}⌺(↑2⌿⊂⍺))w
}
woops, I tried writing everything in general and then the final step only works for matrices, not for nD arrays
BlockUp ← {
⍝ Takes an array as right argument and a vector as left argument.
⍝ ⍺ must have as many elements as ⍵ has dimensions.
⍝ Splits ⍵ in sub-arrays of lengths given by ⍺.
⍝ Assumes i⊃⍺ divides i⊃⍴⍵
w ← ⍵↑⍨ -(⍴⍵)+ 2× ⌈2÷⍨¯1+⍺
(⍺>1)↓({⊂⍵}⌺(↑2/⊂⍺))w
}
