Got an interesting J solution for the Podovan challenge; it's hardly golfy at all, but the method used is interesting. Th Podovan sequence is a linear recurrence, hence one can use that method with the characteristic polynomial of the recurrence relation. The code below does this in the general case _if the polynomial has only simple roots_, which is the case here:
I came up with 10⊥ ¯1+ ⎕D⍳'512' to convert a string of digits to an integer when Google wasn't coming up with much; is that a reasonable way to approach it or a silly way?
@TessellatingHeckler Right. The official way is using ⎕VFI (Verify and Fix Input) which returns two vectors. The first is a Boolean mask indicating which fields were successfully converted, and the second is a vector of the resulting values, with zeros for invalid values:
In general, I keep stuff I want at hand checked out into /X/ and then my startup script loads everything in /X/ into ⎕SE so I can access everything from inside APL through ⎕SE.X.Category.stuff
@Ven Well, originally, that startup was a hack, but it turned out well, so in 17.1 we're ship that functionality out of the box (undocumented, but the code is in APL, so it is fairly easy to see how it works). In 18.0 we'll document how to auto-load whatever you want into whichever location you want.
New toys for the IT Dept at Dyalog who just got a shiny @IBM Power 9 server with a very fancy rack mounted display & keyboard. Looking back 4 years the old 3151 display could be rack mounted but it was not quite as elegant 😉
I could define all invertible covers as inner function bodies, and then use those definitions to define the final covers as main⍫inverse but it is really awkward. Why can't we just implement my extensions for real‽
@dzaima But occurrences of ⊂⍬ in the left argument should be replaced by the "missing" shape. Since no shape is missing to get the product right (0=×/⍴'a') you can put ⍬ there, no?
@Adám so I at least want it to be true for the special ⍴. In any case, usually one wants only one way of how ⍴ works (i.e. only cuts off data, only repeats data, doesn't disturb the data amount)
@dzaima In light of the Classic VCS ASCII Adventure, I really should switch to a different placeholder value and let negative shape indicate flip, as I have previously contemplated.
TMN is great for expressing a lot of things, but over the centuries, it has collected a variety of inconsistent notations, and overly specific notations for what was needed at the time.
In fact, TMN is inherently ambiguous, relying on context and the goodwill of the reader to understand.
Because of these characteristics, TMN is unsuitable for machine evaluation, and is ill-suited to communicate general purpose algorithms.
APL was originally conceived by a mathematician, Ken Iverson, as a replacement for TMN.
He took a small subset of the most common notations from TMN and applied them across the board, while generalising various concepts from TMN that until then only had notation as specific instances of the general concepts.
And now we're finally ready to see some examples of this.
(Oh yes, and being harmonised and generalised as it is, APL happened to become able to be evaluated by a machine…)
So in TMN, you've got the Big Pi and Big Sigma notation for product and sum.
No, APL is traditionally interpreted, just in time, even.
The general concept of product and sum is reducing a list into a scalar using a two-argument ("dyadic") function.
APL generalises this higher-order operation into an operator (in the Heaviside sense) which takes as operand a dyadic function. Thus, product in APL is ×/ and sum is +/
Note also that APL uses a proper × for multiplication. No compromises on good notation from TMN.
APL actually generalises data into a single uniform concept of an array (a tensor if you want) with a (tensor) rank, where a scalar has rank 0, a vector has rank 1, a matrix has rank 2 etc. All functions are generally applicable to all arrays.
@Rick Well, you can reduce (or apply in any way, really) with any function you want.
Let's take another couple of examples of how APL generalises and harmonises TMN:
TMN has infix notations like a+b and superscript notations like a², and also prefix notations like -a and suffix notations like a! and omni-fix notations like |a|
But notice that these fall into just two categories: single-argument (monadic) and two-argument (dyadic) functions.
APL harmonises all monadic functions to be prefix like -a and all dyadic functions to be infix, like a+b
Therefore, factorial is !a and absolute value is |a and square is a*2 (i.e. power is a*b)
Also note that TMN allows "overloading" a single symbol like - to have both an infix and a prefix meaning. This works well with the harmonisation of prefix/infix for everything so that most function symbols have two meanings, one prefix and one infix. E.g. -a is negation and ÷a is reciprocal.
Often, the monadic form is closely related to the dyadic form, only using a "default" left argument, e.g. 0 for - and 1 for ÷ but some have more involved default left arguments and some have less (or in a few cases, completely un)related pairings.
Another example is a*b is power, while *a has default left argument e
Further of interest may be the inverse of * which is denoted ⍟ log (it also looks like a slice through of a tree log) so 10⍟b is log₁₀ b and *b is of course ln b
@Rick All APL interpreters I know of only use numeric evaluation, although some dialects can work with rational numbers and there are systems written in APL that can do some symbolic evaluation.
because a>b will evaluate to 1 or 0 but. But what does it mean to perform such an operation? Is there underlying logic to adding zero as opposed to adding 1
Speaking of which, TMN is a huge mess of conflicting precedence order rules. E.g. identical operations are left-to-right, except multiple exponents and nobody really knows what a/b/c is, or ab/cd for that sake, or whether trigonometric functions precede multiplication, etc. etc.
Iverson harmonised it all into one simple rule. Consider f(g(h(x)))
Let's remove the parentheses, since all these functions are simply monadic prefix functions: f g h x
Clearly, each function takes everything on its right as its right argument. In APL, all functions (no exceptions!) have long right scope. They are right-associative.
@Rick it becomes very easy to debug (at the very least relative to what it would be like having to memorize the precedences of the dozens of infix function builtins APL has, plus user-defined)
In TMN, at first glance at a complicated formula, you have no idea where to begin.
You can of course use parentheses, but if written right, APL probably needs less of those, and you never need them because you can't remember the order of evaluation.
APL also insists on an infix symbol for all dyadic functions, so no more of implied multiplication by juxtaposition. This also allows inline multi-character names for variables and functions. a÷b÷c and a×b÷c×d and abcd are unambiguous etc.
You know about matrix multiplication, and cross products, and dot products. They are all just summations of pair-wise application of multiplication. That is, it is a higher-order operation (just like reduction) but using two operands instead of just one. In this case the operands are + and × but really, it could be any two dyadic functions. APL denotes all of these with +.×
As dzaima alludes to, just like you can multiply a scalar with a vector or a matrix and that pairs up the scalar with each element of the vector/matrix, APL generalises this to all basic computational functions and to tensors of all ranks.
@Rick Generally not. We have some really clever people that have optimised the generalisations for everyone's benefit. Every time they make the interpreter better, all existing applications run faster.
@Rick for the single-character built-ins you can be pretty sure Dyalog has done a lot to optimize them (sequences of built-ins may be optimized too - I'd assume there's special handling of +/ in Dyalog APL for example)
@dzaima Yes, and Dyalog's interpreter uses many of the whichever is the current processor's set of vector instructions, and were using more for each version.
@Rick Ah, then it is of extreme importance how you choose to represent your graph.
another very important thing about APL - arrays are immutable. A←1 2 3 ⋄ ⎕←A + 1 ⋄ ⎕←A would print 2 3 4\n1 2 3 (⋄ is the statement separator character). Dyalog does reference counting and modifies in-place when possible however so that shouldn't be too much of a concern speed-wise
@Rick When you get around to it, search for "aaron hsu dyalog apl graphs"
@Rick There is a related notation to f.g which instead of the "inner product" is the "outer product" — only application of a single dyadic function, between all possible pairings of elements from the left and right argument. Since there is no "secondary" function (like + in +.×) fill that "slot" with a "nil": ∘.×
@Rick just as an aside since you mentioned graphs, I find "dfns" (kind of like Dyalog's standard library) to have lots of interesting functions: dfns.dyalog.com/n_scc.htm
APL often has a single symbol for a fundamental thought concept that only with much effort (if at all) can be described in TMN. How do you for example write the first 10 indices? APL uses the Greek letter corresponding to "i" (for indices), "⍳":
0 and 1 are just bits. In fact, APL internally represents arrays that are intirely made of 0s and 1s as packed bit Booleans, leading to huge speed-ups and memory savings compared the common 1-byte-per-bit representation.
Simple APL can actually beat carefully hand-crafted C in certain such applications.
@Rick OK, lets do one last function, dyadic ↓ which is "drop". a↓b simply drops a cells from b:
