Hmm, looks like some parameters will default a path to the location of the config file itself, while other will not.

How can I run a dyalog script on the (unix) command line?

I keep running into dyalog/mapl which is documented in the manuals, but doesn't seem to have a flag to disable the repl and just run.

Piping input into mapl from a file almost works, but has the opposite problem. It terminates without launching the repl, but never seems to get evaluated.

@AviFS dyalog -script script.dyalog?

yay

Just in time for the next episode…

codegolf.stackexchange.com/q/243614/80214 is this psossible in apl?

it requires creating an arbitrary number of parallel threads, which i understand is only possible with ¨?

      ∇f
[1]  :While 1
[2]  {⎕←(⎕DL 5)⊢⎕}&0
[3]  :EndWhile
[4]  ∇

sadly not a thing

@Adám i mean today's is really easy

identity matrix

True, but several approaches are possible.

@Razetime huh, so Dyalog won't process other threads while a ⎕/⍞ is taking input

{∇&⎕←(⎕dl 1)⊢⍞}0 is kind of close, but breaks if you enter anything during that 5s interval

here's a CBQN solution because why not: •term.Raw 1⋄{𝕊:t←•MonoTime@⋄r←𝕩∾(0⊸≠/⟜⋈⋈⟜t)•term.CharN@⋄m←t>5+1⊑¨r⋄•term.OutRaw 0⊑¨m/r⋄m¬⊸/r}•_while_ 1⟨⟩

↑⍤,⍥⊂ looks like a dazed owl holding a spear. I could use that as a mnemonic. :)

In ⎕ML←3 (APL2-compatibility mode where some functions are slightly different) it looks like ⊃⍤,⍥⊂

I'm on mobile now so can't post my solution but it will pass probably never the less

@Richard This should work on your mobile.

This is pretty fast: {⍵ ⍵⍴1@((⍳+⊢×⍳)⍵)⊢0↑⍨×⍨⍵}. The more obvious {s←⍵ ⍵⍴0⋄(0 0⍉s)←1⋄s} is pretty slow. Both ⎕IO←0.

Interesting. Anyone else?

How about the outer product? ⋄ ∘.=⍨⍳5

@Adám
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

I Ireshaped a matrix with 1 and as many zeros as the dimension

Very good. That's what I wanted to get to. Something like {⍵ ⍵⍴1,⍵↑0}

Can anyone spot why that might be slow?

… and any ideas for how to fix it?

Because the 1 had to be out in front of the zeros

{⍵ ⍵⍴(⍵+1)↑1}?

Correct, both of you!

My first one still the fastest :)

Want to make that tacit?

@xpqz For what sizes?

I tried 1000

      cmpx '{⍵ ⍵⍴1@((⍳+⊢×⍳)⍵)⊢0↑⍨×⍨⍵}1000' '{s←⍵ ⍵⍴0⋄(0 0⍉s)←1⋄s}1000' '∘.=⍨⍳1000' '{⍵ ⍵⍴(⍵+1)↑1}1000'
  {⍵ ⍵⍴1@((⍳+⊢×⍳)⍵)⊢0↑⍨×⍨⍵}1000 → 2.6E¯5 |     0% ⎕
  {s←⍵ ⍵⍴0⋄(0 0⍉s)←1⋄s}1000     → 1.2E¯3 | +4307% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  ∘.=⍨⍳1000                     → 3.3E¯4 | +1162% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
  {⍵ ⍵⍴(⍵+1)↑1}1000             → 3.2E¯5 |   +23% ⎕

I had overtake much faster on 100 and 1000.

my tests

Yeah, similar by me.

im late lol

i'm pretty sure cmpx/]runtime are unreliable for precise timings of things magnitudes faster than the slowest in the list

@dzaima Interesting.

Here's a fun one: ⋄ ⎕IO←0 ⋄ {2⊥⍣¯1⌽2*⍳⍵} 5

@Adám
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

Is mirroring 0 0 0 0 1 faster maybe?

@Richard Surely not faster than generating 1 0 0 0 0 to begin with.

In k: =

:=)

Why is assigning to 0 0⍉ so slow?

Any other approaches? Do we need an "industrial quality" one?

Can APL create an inverse matrix? Then A X A-1 is also the I matrix of I remember correctly. It's not fast off course

I had two approaches, and I'm wondering why the second one is THAT much slower:

    id1 ← ∘.=⍥⍳⍨
    id2 ← =/¨⍳∘(,⍨)
    ]runtime -c 'id1 100' 'id2 100'
id1 100 → 2.4E¯6 |      0%
id2 100 → 1.8E¯3 | +74400% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

@Richard Yeah, nice: ⋄ ⌹⍨?5 5⍴0

@Adám
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

@xpqz just not optimized probably, going a very generic path and copying things slowly

@Adám That's brilliant

Of course, it has a tiny probability of failing. I wonder if we can fix that.

@BojanPetrović The first one uses flat arrays, the second uses nested arrays.

{⌹⍨?⍵ ⍵⍴0}1000                → 5.8E¯1 | +464700% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

Ouch

All nice solutions are dog slow :)

@BojanPetrović Also ∘.=⍥⍳⍨ is the same as ∘.=⍨⍳ but the latter doesn't need to compute ⍳ twice.

@Adám Thanks, I didn't think about that.

@xpqz ∘.=⍨⍳ is probably fine for most uses.

@xpqz beauty may cost more ;)

You betcha

⋄ ↑,⍨\5↑1

@Adám
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

Terribly slow too, of course.

⋄ 1↑⍨⍤0-⍳5

@Adám
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

What was the industrial strength version?

Or 1, 0xj5

@Richard What?

1, 0 times iota 5

0×⍳5 is 5⍴0

Yes

BQN port because why not

⋄ ⍸⍣¯1⍤⊢⌸⍳5

@Adám
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

@Adám ?

I'm guessing that's slow, too

Me too.

Same as ⋄ ⍸⍣¯1⍤,⍤0⍳5

@Adám
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

Can you explain this one?

0=-⍤⍳⌽⍤0 1⍳ reasonably fun

@Richard ⌸ applies ⍸⍣¯1⍤⊢ to each list of indices where a unique element is found. ⍳5 has 1 at 1, 2 at 2, etc. ⍸⍣¯1 generates a Boolean vector of minimal length with 1s in those positions. Due to mixing, 0s are padded on the right.

@rak1507 what sort of voodoo is this

⍸⍣¯1⍤⊢⌸⍳

oh.. I scrolled up

@Richard Each (⍤0) element of ⍳5 fed to ⍸⍣¯1 as before, but we have to ravel ⍤, to make the arguments acceptable to ⍸⍣¯1

Oh, of course, rotating.

⋄ ⎕IO←0 ⋄ (-⍤⍳⌽⍤0 1↑∘1)5

@Adám
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

@rak1507 fun indeed :)

Expand: ⋄ (,⍨⍴1(\⍨)1,-)5

@Adám
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

↑1⌽⍤↑⍨¨⍳

Same thing, really.

=/¨⍳⍤,⍨

0<⌽⍤↑⌸⍤⍳

@rak1507 Slowest so far :)

lol

@rak1507 and I thought I started to read and understandAPL better :)

@xpqz Nah, ⌹ is slower.

Must be a complex arithmetic version somehow

@xpqz ⋄ {4=○÷12○⍵∘.+0j1×⍵}⍳5

@Adám
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

I hope someone submitted that at the time.

OK, have we beaten this one to death?

@Adám Yes, I understand that nested arrays are slower, I was just wondering why so much in this case. Is, for example, bad cache locality the primary issue, or something else?

I think @Richard takes it with {⍵ ⍵⍴(⍵+1)↑1}

Fast and simple.

@BojanPetrović You're generating 10000 pointers!

Maybe something with a cosinus with interval of the dimension and rounded down

@xpqz We never made that tacit. Who want the honours?

@Richard What?

@Adám That's 10000 mallocs, right?

Something like that, but ¨ also has to go chasing each pointer.

⋄ {~×(2*÷2)|10○⍵∘.+0j1×⍵}⍳5

@Adám
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

The number-theoretical edition…

Y'all can keep discussing — I'll see you next week for Home On The Range!

oh no, i missed it.

{⍸⍣¯1⊢,¨⍨⍳⍵} was my solution

@Adám also considered it

@KamilaSzewczyk We had something similar.

@BojanPetrović besides 10000 allocations from ⍳, it's 10000 iterations in the loop of ¨, 10000 separate invocations of =/, and another 10000 allocations for the result number of each =/. Compare that to ∘.=, which should have a native implementation, going through 32 elements at a time (the max number of bytes an AVX2 register can hold)

@Adám I offer ((,⍨⊢)⍴1∘(⊣↑⍨+))

@xpqz You can do much better.

I was quite pleased with that one

@xpqz ,⍨⍴1∘+↑1⍨ or even ,⍨⍴1∘+↑≢

Announcement: APL Seeds '22 is happening on 29 March 2022. Free to attend, but registration is required. See website for details.

(,⍨⍴1∘(+↑⊣) if you truly want that 1 to be deduplicated, even though there's no reason to)

,⍨⍴+∘≢⍨↑≢ ← look ma, no 1s.

@dzaima Thanks, that helps a lot!

@Adám I'll give it a try using cosinus when I am behind my computer again later this week

@Adám is the event phisical or online? can i attend online?

@BrianBED online via zoom

ok good to know

thanks