The APL Orchard

7:08 AM

> You can assume that the length of s1 will always be smaller than 30 and bigger than the length of s2.

@Razetime Are you sure this is right for 'abcdef' f 'abcdefX'?

7:22 AM

@Adám hm, I followed the js answer

maybe not too exactly

Bubbler

The JS answer is wrong in the first place

somehow accepted ⍨

@Bubbler Does this look better?

Bubbler

Haskell answer looks correct, as it transforms Programming to Codegolf in 10 steps, not 11

@Razetime No, yours still takes 11 steps from Programming to Codegolf

(Good luck deciphering the Haskell answer though)

LEarned a bit for husk

but golfy haskell is scary

7:42 AM

I feel like an idiot. I just can't seem to get my head around the behaviour of ⍤.

I mean, I use it often enough in its simple form, but when you have multible arguments with negative values, it breaks down.

7:57 AM

@EliasMårtenson First, you expand the right operand to the 3-item vector form. Then you choose the numbers corresponding to the arguments. If a number is negative, add the rank of the corresponding argument to it. Personally I would then create an array of arrays for each argument, and then do ⊃processedLeft f¨processedRight,

@dzaima Oh, that sounds easy.

I can try to do that. Would you be able to give me a couple of expressions that I can put in my test cases for it?

@EliasMårtenson here's my BQN impl, which should match APL besides the BQN things that don't match

@EliasMårtenson some with 1 argument

@dzaima Thanks! I'll integrate those tests.

Could you help me make one with 2 or 3 args as well?

@dzaima (r() is rank, ia is shape product (item amount), f=⍶,g=⍹,w=⍺,x=⍵, MutVal.cut creates a subarray of an array (i.e. cells is ⊂⍤(-n) or something))

@EliasMårtenson if by 3 args you mean using something else than ⊂, then i'm on it

@dzaima (those are 1-indexed btw ಠ_ಠ)

@EliasMårtenson Check out the APL Wiki article and the Dyalog Webinar mini-series on Rank: 1, 2, 3.

8:10 AM

@dzaima ah, 2 or 3 args in the right argument ಠ_ಠ

@Bubbler After a lot of pain

@Razetime Ouch.

@Adám You mean Ouch

@EliasMårtenson some

@Razetime Yeah. Another test case you should use is ABCxDEF→ABCDEF.

8:14 AM

@Adám That works alright

@dzaima (that doesn't test what should happen if the rank asked for is too high or too low (i.e. ⊂⍤99⊢2 3⍴⍳6) because i don't particularly like what it does)

@Razetime Ah, OK. While you're obviously not done yet, note that your code has a lot of golfing opportunities,

@dzaima I've always wondered why ⍤ doesn't add leading axes when asking for too high rank. I guess the current behaviour is usually what one wants, but it does seem a bit odd.

@Adám yes lemme finish it first

@Adám well, my personal choice would be to error :P

@dzaima I meant something like A (FN ⍤ X Y Z) B. Where X, Y and Z are numbers.

8:20 AM

@EliasMårtenson yeah, understood that. my last batch has some

@dzaima Very much appreciated. I'll put them in the test cases and then work on the implementation.

a bit more with actually expected usage

Quite busy in the office today, and I had to do some errands over lunch so I didn't have time to work on this yet.

(also fwiw ngn/apls tests may be worth looking at, but doesn't give much here as ngn/apl doesn't have ⍤)

@Adám Ready to golf?

8:24 AM

@dzaima (and to think i didn't at all understand how ⍤ worked before i implemented it for dzaima/BQN..)

@dzaima Best way to learn. :-) There are several APL primitives I didn't understand before implementing them.

@EliasMårtenson indeed

@EliasMårtenson Which ones? We should make a point of explaining them more.

a question is how lazy evaluation fits into this. Doing everything lazily would mean each item could be recalculated many times because it's needed (i.e. the 0 10 in 0 10(+⍤¯1)2 5⍴⍳10 has each item requested 5 times)

@RGS I see @rak1507 used ↑ to splice the arrays into one with a higher rank. Not sure if that's what you were waiting for me to find :) But +/↑⍳2 2 and +/¨⍳2 2 seem to give the same result in the end

8:30 AM

@Adám Most recently, ⌽ with array left argument.

Ah. Right.

@xificurC they achieve the same thing indeed. ↑ "exchanges" depth for rank

77 bytes

@Razetime 70

@dzaima they're also equally fast, so i'd even prefer +/¨⍳2 2

8:32 AM

@dzaima Yes, at least initially that would happen. For each function it's a judgement call whether to collapse any of the arguments before returning the lazy result. In this case, it may make sense to collapse it.

@Razetime Now combine the good stuff from ^^^ with your tricks, and you're good to go.

@EliasMårtenson here only one argument would be needed multiple times, so a strategy would be to collapse only it

@Adám looks like yours is shorter

@dzaima (which one that is, i don't know :P)

@dzaima how can I compare the runtime of the two? I saw people using ]runtime but forgot the API

8:35 AM

@xificurC ]runtime -c "+/↑⍳200 200" "+/¨⍳200 200"

@Razetime But you did some other stuff I don't have time to look at now.

not that much lol

I just copypasted an APLcart snippet

  +/¨⍳300 300 → 4.8E¯3 |  0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  +/↑⍳300 300 → 4.8E¯3 | -1% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

oh right, this chat hates multiline

@xificurC it does. You either monospace the whole message (ctrl+k), or none of it

@xificurC eh

I'd like to understand how this crying baby ⍤ works. I guess one can live without it but it seems to be used to simplify/tacify solutions

you provided the definition but an example where a longer solution is simplified by its usage would be more educational at this point

8:44 AM

@xificurC the ⍤ usage in tacit code is a completely different thing than what we talked about implementing above fwiw

@xificurC recall that dice program of {⍳⍺⍴⍵}? With Crying Baby, it's just ⍳⍤⍴

RGS

@xificurC yes, I was thinking something along those lines. But the point of using the Mix function is that you can finish your solution completely in an array-based way, no need to ever loop over the several rolls

so pattern-wise f⍺g⍵ is f⍤g. That actually matches the definition you posted which was {⍺⍺ ⍺ ⍵⍵ ⍵} IIRC

@xificurC yep, precisely :D

but the solutions I see here are often crying babies pointing fingers

@RGS everything's a loop in the end :)

I understood ¨ as map

@xificurC but implicit loops are usually faster in APL than explicit ones

8:50 AM

@dzaima in this case ¨ was faster than ↑ though, as measurements showed, by a whopping 0-5%

@xificurC yeah, that's a side-effect of ⍳ being very bad as it creates a bunch of tiny arrays

I don't see ¨ as an explicit loop though, there's no for(i=0;i<arr.length();i++) there :)

@xificurC f⍤⊢ and f⍤⊣? Those translate to {f⍺⊢⍵} (equal to {f⍵}) and {f⍺⊣⍵} (equal to {f⍺}) and so are just "apply f to left/right argument only"

@xificurC what's "explicit" is relative of course, but ¨ is plenty explicit in APL

my solution to yesterday's rolling problem was simplified by @Adám to {r/⍨⍺≤+/¨r←,⍳⊃⊢⍤/⍨/⍵}. There's a crying baby with a finger :)

@xificurC ⊢⍤/ is quite a special case. It expands to {⍺/⍵}, but because / is schizophrenic, we can't just use / in the expression or it'll choose, against our will, to go with its operator personality