the k tree

nathan rogers

10:00 PM

I have something to work with I'll let you know

can I do value unpacking in args list?

{[(a;b;c);x] ...} @ngn

ngn

@nathanrogers no, but of course you can do it in the function's body

{(a;b;c):x ...}

nathan rogers

I mean for x,y {[(y1;y2;y3); x] ... }[(1;2;3); 10 10#0]

ngn

@nathanrogers any reason for swapping x and y?

nathan rogers

no

again, this is 1 row

of a long table

ngn

it could be {[y;x] (y1;y2;y3):y ...} or if it's ok to use the implicit order of x,y: {(x1;x2;x3):x ...y...}

nathan rogers

10:10 PM

what are the syntax rules of that unpacking?

just any old expression can follow it after a space/

ngn

@nathanrogers unpacking works like an each-ed assignment

nathan rogers

but there's no ; after?

as an expression separator?

ngn

@nathanrogers oh, if you have other statements after it, of course, you should put a ;

nathan rogers

xool

ngn

i omitted it from the examples only to reduce clutter

nathan rogers

10:26 PM

{{(!y)\:/:!x}. {x|-x} x-y}[2 4; 5 5]

@ngn i can't seem to pass the results to the final expression there

the result of the absolute value should be 3 1

I want to pass 3 1 to the last expression on the left, I could do assignment?

{(!*|x)\:/:!*a:{x|-x} x-y}[2 4; 5 5]

but I keep getting rank error

ngn

@nathanrogers shouldn't there be a verb before \:/:?

nathan rogers

oh, hjaha

derp

ngn

"rank error" because you were trying to apply (!y)\:/: to fewer args than required

nathan rogers

{[a;b](!*|z){(&/x)+y,z}[(a;b)]\:/:!*z:{x|-x} a-b}[2 4; 5 5]

ok this does what I want

but its convoluted as shit without lexical scope

ngn

@nathanrogers yes :( that can be painful

nathan rogers

10:31 PM

really, there should be a ⍳ n m

ngn

@nathanrogers "find"? it's x?y

nathan rogers

index range

I want like a (⊂2 4)+⍳2 3

ngn

@nathanrogers i think the odometer is better than apl's ⍳

@nathanrogers 2 4+!2 3 ?

@ngn it gives you a mixed wide matrix instead of the inefficient nested thing ⍳m n gives in apl

nathan rogers

oh!

its like a ↑,⍳2 3

ngn

@nathanrogers yeah, and transposed

nathan rogers

10:36 PM

neat

ok

there's no abs then?

ngn

@nathanrogers no, but i can see you figured it out: x|-x

dzaima

@ngn (would be nicer if each item also had a shape :) (cause of course i have to mention dzaima/APLs ⎕vi←1))

nathan rogers

@ngn does @[...; index; ...] accept a list of indices

or only 1 index

ngn

@dzaima i remember seeing this before but i can't remember what the motivation was..

dzaima

@ngn i've surely mentioned it in every chance possible

ngn

10:40 PM

@dzaima so, ⎕vi changes ⍳⍵ to ↓⍉⍤2↑⍳⍵?

dzaima

@ngn and other things that do with arrays of indexes - @, ⊇; vi being "vector indexing"

ngn

@nathanrogers it accepts lists too, and even lists of lists, and can penetrate them (depends on other args)

@dzaima that's a much better definition of ⍳ but alas, such things in apl are set in stone

@nathanrogers btw, i added \+ \' etc

i hope nobody ever uses help and repl as variable names in the repl :)

nathan rogers

ok I'm almost there

i:(("e"; 2 4; 5 5);("n";3 1; 8 8))
a:"efg"!({~x};{1};{0}) /actions
{@[y; \,+{(x&y)+!{x|-x}x-y}.1_x;a@*x]}[*i;10 10#0]

i is the input a is a dictionary of actions

this say in y, ammend index range of the last 2 elements in x, by action a

but its amending the entire row

and not the indices

ngn

@nathanrogers so you want to start with 10 10#0 and go through the actions and apply them in order?

nathan rogers

right, but this is one step

coltim

10:49 PM

@nathanrogers is {&/[x;y]+/:+!|{x|-x}x-y}[2 4;5 5] equivalent? its result doesn't enlist each uhh, list in the list

nathan rogers

i f / 10 10#0

ngn

@nathanrogers but they are different actions

nathan rogers

I was only + and , to see if my argument was wrong

those don't have to be there

ngn

i mean, amend can apply a verb to multiple indices, but only one verb

nathan rogers

right its amending 1 verb

the verb specified by *x in a

a@*x is the function to amend for a given step

1_x is the range

so I'm trying generate indices for that 1 step

hence {...}[ *i; ...]

because I just want to get 1 step right

ngn

10:52 PM

i see

nathan rogers

but its ammending the entire 3rd and 4th rows

not just the index range

which looks correct

ngn

@nathanrogers ah, in this case you need "dmend" (amend in depth)

nathan rogers

oh, so amend is major cells?

.[y; inds; f] ?

ngn

.[a;i;f;b] is almost the same as @[a;i;f;b] but when i is a list it goes deeper into a

nathan rogers

what is b?

ngn

10:55 PM

@nathanrogers sorry, without b. it's an optional argument when f is dyadic

but in this case you don't need it

nathan rogers

no its still amending the whole row

 {.[y; \,+{(x&y)+!{x|-x}x-y}.1_x;a@*x]}[*i;10 10#0]
,(2 4;3 4;4 4)
(0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0
 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1
 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0)

coltim

@ngn I know that's true with @ but does it also apply to .?

ngn

@coltim it looks like i haven't implemented all of the cases :(

nathan rogers

so this won't work for now?

ngn

@coltim .[x;y;z] is a bit tricky because it's also "try" (when x is a function)

@nathanrogers let's start with something simple, this should work: .[10 10#0;3 4;:;1]

coltim

10:58 PM

@ngn ahh, yeh that's what I was referring to

nathan rogers

.[10 10#0;(3 4;4 4);:;1]

right and this works too

'nyi

not yet implemented ?

ngn

@nathanrogers for negation you can use .[10 10#0;3 4;=;0]

@nathanrogers yes :) arthur uses that abbreviation, so all k-s do too

nathan rogers

:C

coltim

@ngn with this workaround, maybe {y .[;;=;0]/{&/[x;y]+/:+!|{x|-x}x-y}.1_x}[*i;10 10#0] ?

ngn

@nathanrogers ^

nathan rogers

11:06 PM

could do a function applied to a range

ngn

@nathanrogers so, if you have to perform an action on an m×n region, you generate m×n pairs of indices?

nathan rogers

yeah

then a look up and perform some kind of multiplication, since its all 1's and 0's

ngn

perfomance here probably doesn't matter much, but it could be more efficent if you generate ranges separately for the two axes

example: .[10 10#0;(3+!4;4+!5);=;0]

nathan rogers

ok what?

ngn

@nathanrogers it's equivalent to a:10 10#0;a[3+!4;4+!5]=:0;a

nathan rogers

11:10 PM

yes I have my terminal open and I ran it

I don't understand the output

coltim

@nathanrogers I think it's this

nathan rogers

can you explain what it's doing?

I don't see indices

ngn

@nathanrogers 3+!4 are the indices for the first axis, 4+!5 for the second

nathan rogers

I see that

ngn

they identify a certain set of cells, a rectangle in this case

nathan rogers

11:13 PM

yes but the don't specify two dimensional indices

ngn

the verb is applied to the cells in that rectangle - boolean not

nathan rogers

oh

so you're just apply =0 with each row and each column in that list

ngn

@nathanrogers the list (3+!4;4+!5) is of length 2, so..

nathan rogers

right but aren't those single cells?

ngn

@nathanrogers not to the whole row/column. only to the rectangle.

nathan rogers

11:14 PM

(3 4 5 6
4 5 6 7 8)

3 4
4 5
5 6
...

that doesn't look like the result

coltim

it's like right-recursive indexing or something, @ngn can explain it better =P

ngn

@nathanrogers to build intuition, try making a small rectange of letters and indexing it in various ways

example

nathan rogers

i don't have any intuition because that isn't a list of indices

which is what the argument of that position is meant to be

coltim

maybe this ? it's not super intuitive to me either

nathan rogers

I don't have any frame of reference for passing lenghts along 2 indices and not the indices themselves

yes but that \: isn't called anywhere

ngn

11:20 PM

@nathanrogers you're thinking of something like scatter indexing in apl. it's not that. it's more like ⌷-indexing.

nathan rogers

yeah I've never understood ⌷ indexing either

i just get the indices I want in a list and do A[inds]

ngn

@nathanrogers yeah that's scatter indexing

nathan rogers

you mean indexing

ngn

think of A[i;j] where i and j are int vectors

nathan rogers

oh

sure

ngn

11:22 PM

(that's the same as i j⌷A)

nathan rogers

i never knew

ngn

and k's dmend (.[a;(i;j);...]) works the same way

nathan rogers

{.[y; \{(x&y)+'!'{x|-x}x-y}.1_x;=;0]}[*i;10 10#0]

so that way from the original solution

i:(("e"; 2 4; 5 5);("n";3 1; 8 8))
a:"enf"!(=;{(#x)#1};{(#x)#0}) /actions
{.[y; \{(x&y)+'!'{x|-x}x-y}.1_x;a@*x;0]}[*i;10 10#0]

always pass 0, but ignore 0 I guess

ngn

@nathanrogers wouldn't it work with {1} and {0}?

instead of {(#x)#1} and {(#x)#0}

hm.. maybe not

nathan rogers

right

that's what I thought

ngn

11:35 PM

@nathanrogers what's the expected output?

nathan rogers

the matrix

t:10 10#0
i:(("e"; 2 4; 5 5);("n";3 1; 8 8))
a:"enf"!(=;{(#x)#1};{(#x)#0}) /actions
s:{.[y; \{(x&y)+'!'{x|-x}x-y}.1_x;a@*x;0]

so given the initial value t, and the input list i, with actions a, I need to use the solution s for each i, accumulating t

ngn

t s/i

nathan rogers

lmt

what is lmt

ngn

@nathanrogers limit error

nathan rogers

oh my arguments are backwards now

ngn

11:42 PM

yes, i forgot to mention

nathan rogers

'rnk
{[x;y;z;u]@[x;*y;.[;1_y;z;];u]}
^

this isn't anything I've defined

ngn

i:(("e";2 4;5 5);("n";3 1;8 8))
a:"enf"!(=;{y;1};:) /actions
(10 10#0){.[x;{x+!y-x}'/1_y;a@*y;0]}/i

and i must go to bed

nathan rogers

@ngn that solution works if the elements are in sorted order

oh, no I see what you're doing

nvm

chat.stackexchange.com/transcript/message/57313776#57313776 @ngn

this isn't my function

ngn

@nathanrogers some of k is implemented in k :)

nathan rogers

what is '/?

I see, each element is 2, and we're reducing them by the sum of the right with the indices

but that still assumes order right?

Transcript for