« first day (1262 days earlier)      last day (1333 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
 
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)
 
@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 (if i could start over, i'd have the char for that be the same as the one for the regular monadic )
 
@dzaima Yeah, why didn't @Marshall go for for range? That's very intuitive.
 
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)
 
@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 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
 
12:33 AM
@dzaima Yes. Mine is very specifically designed to make it a breeze to hand-write constants.
 
(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)
 
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
 
1:07 AM
there we go (also somehow i never noticed that the scalar matrix pretty-printing still is the APL variant)
 
@dzaima Also multiplying a negative number by zero.
 
@Marshall huh. i guess that's reasonably possible to come across
 
 
6 hours later…
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)
 
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 ''?
 
@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…
1:46 PM
@Adám 1,2 being allowed strikes again
 
 
2 hours later…
3:34 PM
(the "proper" windows idiom would be n,/⍮¨ but of course we don't have either)
 
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
 
@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!
 
@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.)
 
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)
 
@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.
 
@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)
 
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.
 
(also with making •COMP i realized i could just have this instead of a separate •TIME and •HTIME)
 
Reversing every expression when there are lists and functions is surprisingly hard.
 
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
 
@dzaima All the grades are small-range and can be done with an index table.
 
@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
 
6:06 PM
 
 
2 hours later…
8:32 PM
Reversing every expression when there are lists and functions is REALLY hard.
 

« first day (1262 days earlier)      last day (1333 days later) »