Return to Answer

The k function yields a bitmap scaled by 2 (ie. a 2D array of 0s and 2s) so the values can be distinguished from the ice cream values later on, in the mapping.

The k function yields a boolean scaled by 2 so the values can be distinguished from the ice cream values later on, in the mapping.

edit: -6 combine 2 maps into 1.
edit: -2 remove useless ravels.
edit: nicer typescript.
edit: -10 apply repeated expression array-wise.
edit: -4 factor out repeated expression as a function.

i:[((n%2)^2)>+/(qx y)^2 ( )^2 } square the result from q(x,y) +/ } sum the two numbers > } compare the left side (above) with the right (=> 0/1) [ } floor 

edit: -6 combine 2 maps into 1.
edit: -2 remove useless ravels.
edit: nicer typescript.
edit: -10 apply repeated expression array-wise.
edit: -4 factor out repeated expression as a function.
edit: line-by-line commentary.

i:[((n%2)^2)>+/(qx y)^2 ( )^2 } square the result from q(x,y) +/ } sum the two numbers > } compare the left side (above) with the right (=> 0/1) [ } floor 

The floor should not be necessary. But apparently there's a bug in the interpreter.

The l function works similarly to the j function, using a jot-dot.

l:(@1+~]y%2)k.(~y) y%2 } y divided by 2 ] } ceiling ~ } iota 0..ceil(y/2)-1 1+ } add 1 => 1..ceil(y/2) @ } reverse => ceil(y/2)..1 ~y } iota y 0..y-1 ( )k.( ) } jot-dot using k 

The k function yields a bitmap scaled by 2 (ie. a 2D array of 0s and 2s) so the values can be distinguished from the ice cream values later on, in the mapping.

k:2*[x>[|qy x } k's left arg qy } y-(n-1)%2 | } abs [ } floor x } left-hand-side again > } compare [ } floor (should be unnecessary) 2* } scale by 2 

In action (piping through tr to remove tab chars which are the REPL's prompt):

josh@Z1 ~/inca $ cat icecream i:[((n%2)^2)>((x-(n-1)%2)^2)+(y-(n-1)%2)^2 j:(~[y%2)i.(~y) k:2*[x>[|y-(n-1)%2 l:(@1+~]y%2)k.(~y) c:y y#((jn<y),ly){' (V' '' 'c1' c1 '' 'c2' c2 '' 'c3' c3 '' 'c4' c4 '' 'c5' c5 josh@Z1 ~/inca $ ./inca2 <icecream | tr -d '\t' c1 V c2 (( VV c3 ((( VVV V c4 (( (((( VVVV VV c5 ((( ((((( VVVVV VVV V josh@Z1 ~/inca $ 

In more detail, the entry-point is the c function which takes one argument implicitly named y.

c:y y#((jn<y),ly){' (V'   n<y } assign y to 'n'  jn<y } call j(y) ly } call l(y) (( ), ) } catenate the results ( ){' (V' } map 0 1 2 to ' ' '(' 'V' y y# } reshape to NxN 

The j function receives the same input value as its y parameter.

j:(~[y%2)i.(~y)  y%2 } y divided by 2  [ } floor ~ } iota. this generates the row indices 0..y/2 ~y } iota y. this generates the column indices 0..y ( )i.( ) } jot-dot with the function i 

The jot-dot here does the double-loop. It calls the i function with every combination of elements from the left and right arrays (0..n/2 and 0..n). So the i function receives as x the y index of the table, and it receives as y the x index. The names got a little backwards here :).

i:[((n%2)^2)>+/(qx y)^2  n%2 } n divided by 2  (n%2)^2 } squared  x y } make a 2-element array (x,y)  qx y } call q on this array   

where q does

q:y-(n-1)%2  n-1 } n minus 1  %2 } divided by 2  y- } y minus that 

back to i

i:[((n%2)^2)>+/(qx y)^2  ( )^2 } square the result from q(x,y)  +/ } sum the two numbers  > } compare the left side (above) with the right (=> 0/1)  [ } floor 

In action (piping through tr to remove tab chars which are the REPL's prompt):

josh@Z1 ~/inca $ ./inca2 <icecream | tr -d '\t' c1 V c2 (( VV c3 ((( VVV V c4 (( (((( VVVV VV c5 ((( ((((( VVVVV VVV V josh@Z1 ~/inca $