/\⌿⍀,⍪
Contents
/\⌿⍀,⍪#
Replicate /#
Next up is /. When what’s on its left is an array rather than a function it instead acts like a function, which makes it unusual. We cover the operator case of / elsewhere, e.g. +/ for sum.
As a function, / is called replicate. It replicates each element on the right to as many copies as indicated by the corresponding element on the left:
1 1 2 1 2 1 2 1/'Misisipi'
Mississippi
A more common usage is with a Boolean left argument, where it then acts as a filter:
1 0 1 1 0 0 1 0 1 1 1/'Hello World'
HllWrld
It has one more trick: if you use a negative number, then it replaces the corresponding element with that many prototypes (spaces for characters and zeros for numbers):
1 1 ¯1 1 1/'Hello'
He lo
You can also use a single scalar to “empty” an array:
0/'abc'
1/'abc'
abc
1/x can also be used to ensure that x has at least one dimension (it ravels scalars, leaving all other arrays untouched):
⍴1/8 ⍝ Scalar becomes vector, rank 1
⍴1/8 8 ⍝ Higher ranks remain untouched
1
2
Expand \#
/ has a cousin, \, which, when used as a function, is called expand.
Positive numbers on the left also replicate like with / but negative numbers insert that many prototypical elements at that position:
1 1 ¯1 1 1 1\1 2 3 4 5
1 2 0 3 4 5
You can use 0 instead of ¯1 which makes it convenient to use Boolean left arguments.
We can now begin to see how we can insert into an array. Let’s go back to the problem of inserting 3 in between 2 and 4 in the list 1 2 4 5. Our method was:
Get the indices of the elements:
⍳≢1 2 4 5
1 2 3 4
Look where the index is 2:
2=⍳≢1 2 4 5
0 1 0 0
That’s where we want to expand:
1+2=⍳≢1 2 4 5
1 2 1 1
Use \ to perform the expansion:
(1+2=⍳≢1 2 4 5)\1 2 4 5
1 2 2 4 5
Replace the extra 2 with our desired element:
3@(1+2)⊢(1+2=⍳≢1 2 4 5)\1 2 4 5
1 2 3 4 5
Just like the operators / and \ each have a sibling, ⌿ and ⍀ which do the same thing but along the first axis (i.e. on the major cells) so to with the functions / and \:
(1 0 1/3 3⍴⎕A) (1 0 1⌿3 3⍴⎕A)
(1 ¯2 1 1\3 3⍴⎕A) (1 ¯2 1 1⍀3 3⍴⎕A)
┌──┬───┐ │AC│ABC│ │DF│GHI│ │GI│ │ └──┴───┘
┌─────┬───┐ │A BC│ABC│ │D EF│ │ │G HI│ │ │ │DEF│ │ │GHI│ └─────┴───┘
Ravel ,#
Monadic , ravels. It takes all the scalars of an array and makes a single vector (list) out of them. This includes a scalar, so ,3 is a one-element vector:
3 3⍴⎕A
,3 3⍴⎕A
ABC DEF GHI
ABCDEFGHI
Question:
Isn’t that the same as monadic
∊?
It is not. For example,
∊3 3⍴⎕A
∊3 3 3⍴⍳27
ABCDEFGHI
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
The difference is that ∊ will take all the data and make it a simple vector. , will take all the scalars and make it a (potentially nested) vector:
∊2 2⍴'abc' 'def' 'ghi' 'jkl'
,2 2⍴'abc' 'def' 'ghi' 'jkl'
abcdefghijkl
┌───┬───┬───┬───┐ │abc│def│ghi│jkl│ └───┴───┴───┴───┘
∊ is the same as recursive application of ⊃,/.
Catenate ,#
Which brings us to dyadic ,, catenate, which is simply concatenation:
1 2 3,4 5 6
1 2 3 4 5 6
, can also get specified an axis upon which to act:
(2 3⍴⎕A),[1](2 3⍴⍳6)
(2 3⍴⎕A),[2](2 3⍴⍳6)
A B C D E F 1 2 3 4 5 6
ABC 1 2 3 DEF 4 5 6
You can even use fractional axes to specify that you want to concatenate along a new inserted axis between the next lower and higher integer axes:
(2 3⍴⎕A),[0.5](2 3⍴⍳6) ⍝ 3D array
(2 3⍴⎕A),[1.5](2 3⍴⍳6) ⍝ 3D array
A B C D E F 1 2 3 4 5 6
A B C 1 2 3 D E F 4 5 6
This works for the monadic form too:
,[0.5]2 3⍴⎕A
⍴,[0.5]2 3⍴⎕A
,[1.5]2 3⍴⎕A
⍴,[1.5]2 3⍴⎕A
ABC DEF
1 2 3
ABC DEF
2 1 3
Catenate first ⍪#
Then we have ⍪. The dyadic ⍪ is a synonym for ,[1], and it’s sometimes referred to as catenate first:
(2 3⍴⎕A),[1](2 3⍴⍳6)
(2 3⍴⎕A)⍪(2 3⍴⍳6)
A B C D E F 1 2 3 4 5 6
A B C D E F 1 2 3 4 5 6
Table ⍪#
Monadic ⍪ is called table as it ensures that the result is a table. It ravels the major cells of an array and makes each one of them into a row (i.e. a major cell) of a matrix:
2 3 4⍴⎕A
⍪2 3 4⍴⎕A
ABCD EFGH IJKL MNOP QRST UVWX
ABCDEFGHIJKL MNOPQRSTUVWX
That is, monadic ⍪ is just a synonym for ,⍤¯1 (except for scalars). To be universal, we’d need to say {,⍤¯1⊢1/⍵}.