The APL Orchard

« first day (1262 days earlier) ← previous day next day → last day (1382 days later) »

12:01 AM

@Adám (i might change mine to be ⍬≡4…3)

@dzaima I'd like to add NARS2000's behaviour for nested arguments, but I'm not sure if that can work with multi-element arguments too.

I really like that this works:

      1…10 20…100 80…0
1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90 100 80 60 40 20 0
      'a'…'zA'…'Z'
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

dzaima

i'd probably make mine equivalent to ⊣+ᑈ∘⍳1-- with ⎕IO←0

(imo some form of … is a very important built-in to have in a non-constant ⎕IO world)

Adám

@dzaima Yes, that makes sense too. But maybe that should be the result when the arguments are enclosed?

On the other hand, ⍳Jv… Hm.

dzaima

@dzaima (if i could start over, i'd have the char for that be the same as the one for the regular monadic ⍳)

Adám

@dzaima Yeah, why didn't @Marshall go for … for range? That's very intuitive.

dzaima

12:17 AM

@Adám hm, didn't really think about using it for the monadic case too (does make a lot of sense; and either way, adding dyadic … was definitely on my todo list when i get to adding my own features)

@Adám kind of annoying to use then (i guess …⍥⊂ but i'd imagine it'd be by far the usual usage)

Adám

@dzaima True. My current definition is very odd for a primitive (so is NARS2000's), but practical for a very specific purpose. With a more regular definition, there's no neat way to use it inline or specify the step size.

dzaima

@dzaima has the somewhat weird consequence of extending scalars, but i don't think that's that bad really

@Adám when wanting a step size, i'd imagine in most cases you'd be thinking in other terms than start & end-point too

Adám

12:33 AM

@dzaima Yes. Mine is very specifically designed to make it a breeze to hand-write constants.

dzaima

(my mind went down couple layers of off-topicness and arrived at a potential solution for comparison tolerance - have a built-in that gives the percentage distance between args, and just check if that's less or greater than the wanted error - a 3-char train should be okay for what already shouldn't be needed anyways)

dzaima

12:53 AM

@dzaima hm, probably reasonable to do that with ⎉. afaik (and i haven't tried to disprove this at all), ¯0 only comes from negation and ÷¯∞, the first probably being from wanting this exact behavior and the latter definitely not ever happening

dzaima

1:07 AM

there we go (also somehow i never noticed that the scalar matrix pretty-printing still is the APL variant)

Marshall

@dzaima Also multiplying a negative number by zero.

dzaima

@Marshall huh. i guess that's reasonably possible to come across

dzaima

1:43 AM

another "huh"

6 hours later…

Adám

7:19 AM

CMQ: What should 1,/3⍴0 give?

(4⍴⊂0⍴0) ≡ (0,/3⍴0)
   cmq   ≡ (1,/3⍴0)
(2⍴⊂2⍴0) ≡ (2,/3⍴0)
(1⍴⊂3⍴0) ≡ (3,/3⍴0)

Bubbler

8:11 AM

I guess 1 f/ should be a no-op for any f.

n f/ means to apply f/ over length-n windows, and reduction over length-1 window gives the item unmodified (f is called zero times).

That said, 0 f/ would give an array filled with identity element, having one higher length on the axis.

RGS

8:34 AM

@Bubbler identify of f? That would be cool... Or do you mean an array of 0s or ''?

Adám

@Bubbler Wouldn't it give an array (one higher length) filled with f-reduced empty arrays? For a vector, it'd be (1+≢v)⍴⊂f/0⍴v

5 hours later…

dzaima

1:46 PM

@Adám 1,2 being allowed strikes again

2 hours later…

dzaima

3:34 PM

(the "proper" windows idiom would be n,/⍮¨ but of course we don't have ⍮ either)

dzaima

4:26 PM

..100x speedup since then:
https://dzaima.github.io/paste/#0zZTNSsNAFIX3PsUwqxbpkDuT@clWpIIbfYPS2CqFmJa2iiBCESm12lIhpSKuigsXLoVuxIV5k3kSJyYxZmWWGbI493Az9@NwE4SQvl1fYj2bYz1aNw7rBwjv7rX9uo@xq8cLpu9u9HTdMrLihiu3WrPDFQ1XYPxKpeZWt/XkqVUNN8ajGOOrr1c9XoJlDjItyFzaO@5v6eBeB6P/nrfCZvGehZl93b7o9VF8THXU9LxBJIbdYdNDp4PYbp6f/GgjzTvPBcZ@FDaL97xEvPvdjr9z1vGGHd9UiEdxRgIhAOJQ4TimsohxKVMl4NXjhwagLGHkpMQSGLGEzSyWEEuH0lIQL/PEMstYEaYkl5BmDOCUgXgyzREDpMS2ZASUzThNiE3cUArizxwxtVNi4BZRwAT9zVjQUuzxdJHPWKTEAhQBkEKqhJgpwUpBHOT3mGZfHieOpFzaMTHj0ilFxrM5Qn@J0z02CyyJUtxS8VZEtSoH8SafMcv@FUwRKplIMraASh4TBwUGvxc2i/c8fgM#BQN18

AviFS

@Adám For some reason your tag is no longer working in V'dibarta Bam. Since it's your second favorite room, I thought I'd let you know you might be missing stuff!

Marshall

@dzaima How fast is the dzaima/BQN compiler? Doesn't look like there's a comparable string to bytecode function I can compare against.

(I don't expect dc.bqn to be faster now, but I think it could be with enough improvements to the runtime.)

dzaima

4:44 PM

@Marshall there isn't, i've been using stuff like 1e6•TIME"⍎""2+2""" the few times i've been interested. Making the compiler fast is definitely not a priority of mine though

it does include executing the string, but still it's quite a bit faster than the 435788ns of DGenFn

with a quick&dirty •CTIME

(heh, both are still faster than dzaima/APL)

Marshall

@dzaima Factor of <50 doesn't sound far at all, considering Take is still emulated.

And the parser's incomplete but about 2/3 of the work is in the tokenizer right now.

dzaima

@Marshall for the 10k runs the sum of the builtin time is 2677ms and total execution time is 4357ms, so there's really only a max 2x potential by adding the rest of the builtin impls

(many of my builtins are the generic Value variant though, there's definitely a lot of speed to gain by special-casing DoubleArrs everywhere)

(i've been helpfully marking things with // valuecopy when all a thing is doing is copying things from arrays around for when i make a generic concatenator that manages multiple types by itself)

(also if you're curious, this is what i'm using to time the reference builtins)

Adám

5:02 PM

@AviFS After a whiles absence, one ceases to be pingable. Not to worry, I never hang out there. I just move off-topic conversation there.

dzaima

(also with making •COMP i realized i could just have this instead of a separate •TIME and •HTIME)

Marshall

Reversing every expression when there are lists and functions is surprisingly hard.

dzaima

5:19 PM

while this only includes the timings of things called by the bytecode (i.e. doesn't count trains), it's still probably interesting:
https://dzaima.github.io/paste/#0zVtbaxVXFH73VwznySBO9rrsG1gfbLVQir1R8K0kOdEGkmijvdBaCKWEJBobaSRS@tAGRR98LPjSWjD/5PyS7pk5s/fMPh4biZAVxJwZdsjH4tvr@9YlRVHMLNwsBrNfXl9ZnB1@P7e0Mjd7benW7IVPLs8OF8r5r1YHo/V/B2tz3w6K0frBxStTzt68sbgQ3q0tXh2cKorq6I2ra6dGe3dHe@v/9@/ZEd686YHd8Lt/WvzuxlrRfIWnhbnl5Zvh@63rt@aWi5Wb9cu5b67VH@uH8DO/HwHv30d486YHHlV4z60URcIb/gdovqtSAaOtH8JnBeitALyjx9vDDHFhWpDgtXIRMaEGCYjv/pPHuIggkQh8RIweWEaMc8SoImJtDHRY4UhGjCdYgRGx0ToGHAitl4B468/piElZzxGxJhk3b/Np…

Marshall

@dzaima All the grades are small-range and can be done with an index table.

dzaima

@Marshall (first of all, they shouldn't convert the doubles to Nums and use Integer[]s for sorting..)

i wonder if there's some way IntelliJ IDEA could allow me to insert a middle-man for all calls

managed to get it to work:
https://dzaima.github.io/paste/#0zVlNaxxHEL37Vwx7kjBqd1V/VYOTQwgO5JL8gyBl5SCQZCMrIZAETAhiJWtlOVGQMTkkik188DGgS@KD9U/ml6Rmdqd7psMk0q2WPcw0szuP4vWr96qrqqoPL76Z1POTSf344rNP731STT78aHP33u5kslEfnJr6yQ/10cWUL1c2rs43Vtfs1TlenQOvr6ysbazermcvpqtXl7yGk8nku3ev64OfQfOn4kcq/tOH9/du1WfH9dnj//u@ueH6NZ855dd/v/n1w71q8eG7z9e3tx@1V/sP9te3q51Hi/X1r75or/mSf/TLNd771w3Xr/nMywbz3Z2qypiryjdlba8qowIEHS3fadUse5CB@epyOgQNfdBkjaHQgTZkZYBuGD5ADSaj9soZqx02d4taOyGoXx2NE8SraNCD62oN4MTUeme01kGBRmt9orUTw5Dfp/@B2gcfyWTUUQbqbwt@xIy5IkWELasXmCNJqfSzIWrsVRqMAgzO5UoHGajfL1TPJszgudAeADrMFlFIpY//no7pB5AKB…

dzaima

6:06 PM

heh

2 hours later…

Marshall

8:32 PM

Reversing every expression when there are lists and functions is REALLY hard.

« first day (1262 days earlier) ← previous day next day → last day (1382 days later) »

all rooms