The APL Orchard

B. Wilson

3:59 AM

@RubenVerg I'm trying to get ngn-k packaged for my Linux distro, but the distro maintainers initially rejected my submission because they thought the code was intentionally obfuscated.

It's taken a bit of back and for to get them to the merely incredulous state.

Richard

7:29 AM

@Adám

⌽⍤↑'⎕'/⍨¨⍳

RubenVerg

10:30 AM

@Silas why:(((

what's the fun in making intentionally unparseable code?

this feels like a bad version of code golf

Adám

1:00 PM

Welcome to APL Quest 2022-5! Today's quest is Stairway to Heaven:

> Write a function that:

> • takes a scalar integer argument, n, in the range 0-100.

> • returns a character matrix comprised of spaces and ⎕ that resembles an n-level left-to-right ascending stairway.

E.g. if given 10, return this matrix:

         ⎕
        ⎕⎕
       ⎕⎕⎕
      ⎕⎕⎕⎕
     ⎕⎕⎕⎕⎕
    ⎕⎕⎕⎕⎕⎕
   ⎕⎕⎕⎕⎕⎕⎕
  ⎕⎕⎕⎕⎕⎕⎕⎕
 ⎕⎕⎕⎕⎕⎕⎕⎕⎕
⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

There are at least a couple of good approaches to this.

RubenVerg

⌽⍤↑'⎕'⍴¨⍨⍳

Adám

Right, but can you stay flat?

@RubenVerg Do you know the defintion of ¨?

rabbitgrowth

{' ⎕'[1+⍵<∘.+⍨⍳⍵]}

RubenVerg

was about to send the same thing!

Adám

Me too.

RubenVerg

1:05 PM

@Adám rank zero + some boxing stuff?

Adám

Yes: f¨ ⇔ ⊂⍤f⍥⊃⍤0

So if we put this into your solution, we have ⌽⍤↑'⎕'⊂⍤⍴⍤0⍥⊃⍨⍳

RubenVerg

⌽⍴∘'⎕'⍤0⊢⍳⍵?

or ⌽'⎕'⍴⍨⍤0⍳

Adám

Yes, nice.

Even better might be moving the ⍨ to the right of 0 so it isn't done every time around the loop.

Here's another fun one: {⌽↑,\⍵⍴'⎕'}

Can you spot the cases where it'll fail?

RubenVerg

I assume it's with 0 but I can't figure out why

Adám

That's one of them.

RubenVerg

1:14 PM

@rabbitgrowth here is another one, quite similar: ' ⎕'⊇⍨0≤∘.-∘⌽⍨⍤⍳

rabbitgrowth

and 1 as well

Adám

0⍴'⎕' gives '' and ,\ is a no-op. So are ↑ and ⌽. But we wanted 0 0⍴'' not ''

@rabbitgrowth Right!

rabbitgrowth

So that's why the APLcart entry for prefixes of a vector is ,¨,\ and not just ,\

RubenVerg

@Adám does the tryapl page consider 1 an extra-point case?

Adám

@rabbitgrowth Yes. (Double your backticks!)

rabbitgrowth

1:17 PM

oops

Adám

@RubenVerg Yes, both 1 and 0.

… but it also normalises your result to a matrix, so it'll accept '⎕' and ,'⎕' for 1!

Maybe I should remove that normalisation?

rabbitgrowth

Sounds like a good idea

RubenVerg

liking '⎕' but not '' seems like weird behavior, they are both the correct result when matricized

rabbitgrowth

@RubenVerg ⊇⍨?

RubenVerg

@rabbitgrowth sane indexing

Adám

1:20 PM

@RubenVerg No, the matrix version of '' is 1 0⍴'' not 0 0⍴''

@RubenVerg Hey, we should update that page to include my user meeting talk.

RubenVerg

@Adám ⍴⍪'' gives 0 1, not 1 0

Adám

@RubenVerg Yes, but the normalisation done is creating a matrix that displays identically.

RubenVerg

ah, I see

rabbitgrowth

@RubenVerg ah I see, my brain just parsed it as ⊆

didn't even notice it was the other way round

Adám

Anyway, did we finish this one?

rabbitgrowth

1:27 PM

{⌽' ⎕'[1+∘.≥⍨⍳⍵]}

nothing terribly exciting

Adám

No, but you might want to reverse the Boolean matrix for performance.

rabbitgrowth

oh, why is that faster?

Adám

A ' ⎕'-array takes up 16 times as much memory per element as a Boolean array!

      'cmpx'⎕CY'dfns'
      A←{⌽' ⎕'[1+∘.≥⍨⍳⍵]}
      B←{' ⎕'[1+⌽∘.≥⍨⍳⍵]}
      cmpx'A 1000' 'B 1000'
  A 1000 → 7.0E¯4 |   0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  B 1000 → 3.2E¯4 | -55% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

Another option is reversing the indices, but they use 8 bits per element, so I'd expect performance to fall between these two…

rabbitgrowth

hm, it seems non-obvious that it's slower to reverse an array that takes up more memory

Adám

In today's world, computation is mostly free. The limit is memory read/write.

RubenVerg

1:32 PM

do arrays own their memory?

Adám

Not sure what that means.

RubenVerg

do, say, vec and 1↓vec duplicate all elements of the vector or does the second array in some way point to the same buffer as the first one?

rabbitgrowth

@Adám so after you reverse it, you'd have to write it back, and that's the slow part?

Adám

1↓vec duplicates. However, two arrays can point to exactly the same data.

@rabbitgrowth Well, a reversal can be done in-place (unless ↑)

@Adám … yup:

      C←{' ⎕'[⌽1+∘.≥⍨⍳⍵]}
      cmpx'A 5000' 'B 5000' 'C 5000'
  A 5000 → 1.6E¯2 |   0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  B 5000 → 1.1E¯2 | -33% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  C 5000 → 1.3E¯2 | -18% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

Should we do a grand comparison of all our solutions?

Oh, btw, I suspect changing ⎕IO to 0 might provide a speed-up for the indexing solutions.

rabbitgrowth

yes please!

RubenVerg

1:38 PM

I'll bet the reshape one is faster than the indexing ones

Adám

      B←{' ⎕'[1+⌽∘.≥⍨⍳⍵]}
      B0←{i←⍳⍵ ⋄ ⎕IO←0 ⋄ ' ⎕'[⌽∘.≥⍨i]}
      cmpx'B 1000' 'B0 1000'
  B 1000  → 3.7E¯4 |   0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  B0 1000 → 2.3E¯4 | -38% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

We want to use ⍳ before changing ⎕IO to avoid 1+ there.

RubenVerg

do we?

i don't think anything's different if the numbers are [0..n) instead of [1..n]

Adám

How will you generate 1…n with ⎕IO←1?

RubenVerg

wdym?

for ∘.≥⍨ the numbers could start from 0, 1, or 95, it doesn't matter as long as they're in sequence

Adám

D'oh. Stupid me.

rabbitgrowth

1:45 PM

I don't get it. Why not just {⎕IO←0 ⋄ ' ⎕'[⌽∘.≥⍨⍳⍵]}?

Adám

Exactly @RubenVerg's point.

rabbitgrowth

Sorry, I'm on mobile and a bit slow

RubenVerg

what does a star next to a cmpx result mean?

Adám

The results differed.

RubenVerg

oh right forgot to account for index origin

anyway, I'm getting a lot of fluctuation in the results

Adám

1:47 PM

You might be using too small an argument.

RubenVerg

      cmpx 'A 5000' 'B 5000' 'C 5000' 'D 5000'
  A 5000 → 2.2E¯2 |   0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  B 5000 → 2.0E¯2 | -12% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  C 5000 → 8.1E¯3 | -64% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  D 5000 → 2.2E¯2 |  +1% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
      cmpx 'A 5000' 'B 5000' 'C 5000' 'D 5000'
  A 5000 → 2.2E¯2 |   0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  B 5000 → 1.9E¯2 | -16% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  C 5000 → 7.4E¯3 | -67% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  D 5000 → 2.8E¯2 | +25% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

B is your RV2, it seems to change a lot

Adám

That is a lot of fluctuation. Could your computer be busy with something?

@RubenVerg I'm renaming them to increase readability…

RubenVerg

@Adám not really, but it's also not a great machine, might just be busy with background OS stuff

I'll just wait for yours :)

Adám

OK, I'm using

  ⎕CLEAR
  A←⌽⍤↑'⎕'⍴¨⍨⍳
  B←{' ⎕'[1+⍵<∘.+⍨⍳⍵]}
  C←{⎕IO←0 ⋄ ' ⎕'[(⍵-2)<∘.+⍨⍳⍵]}
  D←⌽'⎕'⍴⍨⍤0⍳
  E←{⎕IO←0 ⋄ ' ⎕'[0≤∘.-∘⌽⍨⍤⍳⍵]}
  F←{' ⎕'[1+⌽∘.≥⍨⍳⍵]}
  G←{⎕IO←0 ⋄ ' ⎕'[⌽∘.≥⍨⍳⍵]}
  'cmpx'⎕CY'dfns'
  cmpx,∘' 1000'¨⎕A⎕NL¯3

First run:

  A 1000 → 6.2E¯4 |   0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  B 1000 → 7.2E¯4 | +15% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  C 1000 → 6.0E¯4 |  -4% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  D 1000 → 6.2E¯4 |  -1% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  E 1000 → 5.6E¯4 | -11% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  F 1000 → 3.6E¯4 | -42% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  G 1000 → 2.3E¯4 | -64% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

Second run:

  A 1000 → 6.2E¯4 |   0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  B 1000 → 7.2E¯4 | +17% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  C 1000 → 6.4E¯4 |  +3% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  D 1000 → 6.2E¯4 |   0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  E 1000 → 5.6E¯4 | -10% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  F 1000 → 3.6E¯4 | -42% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  G 1000 → 2.3E¯4 | -63% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

But I think we can do better than {⎕IO←0 ⋄ ' ⎕'[⌽∘.≥⍨⍳⍵]}

      cmpx'A 1000' 'G 1000' 'H 1000'
  A 1000 → 6.0E¯4 |   0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  G 1000 → 2.3E¯4 | -62% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  H 1000 → 1.8E¯4 | -70% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

rabbitgrowth

oh, so using ⍤0 instead of ¨ only sped it up by a tiny bit

Adám

1:57 PM

Right, because they are the same under the covers, in the general case.

Btw, I left out my fun solution as it is terrible:

      cmpx'A 1000' '{⌽↑,\⍵⍴''⎕''}1000'
  A 1000          → 5.9E¯4 |      0%
  {⌽↑,\⍵⍴'⎕'}1000 → 9.1E¯2 | +15142% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

rabbitgrowth

😬

Adám

OK, that'll be enough for today. See you next week for 2022-6: Pyramid Scheme!

rabbitgrowth

@Adám not seeing how at the moment, any hints?

RubenVerg

2:42 PM

@Adám how about reversing the input list rather than the computed matrix?

Jack

8:36 PM

Hi everyone, I don't know if this is the right place to ask, so if it isn't please redirect me :)

I'm very much a newcomer to this language, so I'm starting out by trying to solve simple problems: right now I'm trying to write a function that computes the element-wise sum of two vectors when both elements are non zero, and returns 0 otherwise. For example:

¯1 1 1 f 0 1 ¯2

yields 0 2 ¯1

Because I'm currently struggling with trains, I tried to write a tacit function to perform this operation, and I came up with this abomination:

Transcript for