# Vocabulary/bslashdot

Rank Infinity -- operates on x and y as a whole, by items of y -- WHY IS THIS IMPORTANT?

(u\. y) applies verb u to successive suffixes of list y of decreasing length

```   ]\. 'banana'
banana
anana
nana
ana
na
a
```

The main use is the form u/\.

```   +/\. 3 1 4 1 5 9   NB. Compute reverse running total
23 20 19 15 14 9
```

### Common Uses

u\. y is magic when u is of the form u/ -- look what happens then:

```   u =: dyad define   NB. Displays the arguments of u
x , ' u ' , y
)
u/\. 'abcdef'
a u b u c u d u e u f
b u c u d u e u f
c u d u e u f
d u e u f
e u f
f
```

This result is calculated in reverse order, so that u is applied between larger and larger suffixes of y. The effect is of a loop, when on each iteration one more item of y in operated on.

Example: suppose u is: +

```   plus =: dyad define
x , ' + ' , y
)
plus/\. 'abcdef'
a + b + c + d + e + f
b + c + d + e + f
c + d + e + f
d + e + f
e + f
f
```

Get the idea? The operand u is applied between longer and longer suffixes of y. It's a loop that reports the results of each iteration.

With J's right-to-left execution, u/\. y is much more efficient than u/\ y when u is not a primitive.

```   u =: dyad define     NB. Displays the arguments of u
'(' , x , ' u ' , y , ')'
)
u/\. 'abcdef'
(a u (b u (c u (d u (e u f)))))
(b u (c u (d u (e u f))))
(c u (d u (e u f)))
(d u (e u f))
(e u f)
f
```

Note that each row can be calculated with a single application of u using the result from the following row.

1. When y has exactly 2 items, u/\.y is a good way to replace the first item with a function of y while leaving the second item unchanged.

```   >./\. 2 3   NB. Replace first item with max of items
3 3
```

2. To apply a complicated verb for each item of y, retaining the results of each iteration

```   NB. Replace missing data (represented by _) with the following valid item.
]d =: 3 1 _ 1 5 _ _ 2 3 5 _ 9 7 _   NB. Data line
3 1 _ 1 5 _ _ 2 3 5 _ 9 7 _
[^:(_ ~: [)/\. d                    NB. Use left argument unless it is _; then use right
3 1 1 1 5 2 2 2 3 5 9 9 7 _
[^:(_ ~: [)/\.&.(,&0) d             NB. append an initial value to handle last item
3 1 1 1 5 2 2 2 3 5 9 9 7 0
```

If you wanted to replace missing data with the previous item, you could use u/\ y, but that would be a mistake. You should continue to use u/\. y, but reverse the order of y before and after the computation using &.|.

```   d
3 1 _ 1 5 _ _ 2 3 5 _ 9 7 _
[^:(_ ~: [)/\.&.(,&0)&.|. d
3 1 1 1 5 5 5 2 3 5 5 9 7 7
```

1. The last item of y is not changed by  u/\. y . (It could be changed by more general u in  u\. y) .

### Details

1. u can be a cyclic gerund.

2. The argument to each invocation of u is a list of items of y (this has the same rank as y unless y is an atom).

3. If y has no items, the result of  u\. y will also have no items. However, u will be executed once on a 0-item cell to establish the shape of a result of u, and then the result of u\. y will be a list of 0 of that shape:

```   \$ ]\. ''       NB. u is executed on cell of shape 0
0 0
\$ {.\. ''      NB. u produces an atomic result
0
\$ {.\. i. 0 3  NB. u is executed on cell of shape 0 3, returns shape 3
0 3
\$ ]\. i. 0 3   NB. u is executed on cell of shape 0 3, returns shape 0 3
0 0 3
```

### Use These Combinations

Combinations using u\. y that have exceptionally good performance include:

 What it does Type; Precisions; Ranks Syntax Variants; Restrictions Benefits; Bug Warnings Create list of integers from 1 to # y, or the reverse #\ y also #\. which is the reverse faster than >:@i.@# y

Rank 0 _ -- operates on atoms of x, and the entirety of y -- WHY IS THIS IMPORTANT?

(x u\. y) applies verb u to successive outfixes of y. Each outfix is y with an infix removed. The infixes depend on x, as described in Infix (\).

### Common uses

1. Enumerate the faces of a simplex

```    ]simplex =: _3 ]\ 0 0 0  1 0 0  0 1 0  0 0 1  NB. A simplex
0 0 0
1 0 0
0 1 0
0 0 1
1 ]\. simplex     NB. The 4 faces
1 0 0
0 1 0
0 0 1

0 0 0
0 1 0
0 0 1

0 0 0
1 0 0
0 0 1

0 0 0
1 0 0
0 1 0
```

2. Return a vector with each successive single item removed.

```   _1]\. 1 2 3 4
2 3 4
1 3 4
1 2 4
1 2 3
```

### Details

1. u can be a cyclic gerund.

2. The argument to each invocation of u is a list of items of y (this has the same rank as y unless y is an atom).

3. If y has no items, or not enough items to create an outfix, the result of x u\. y will also have no items. However, u will be executed once on an empty cell to establish the shape of a result of u, and then the result of x u\. y will be a list of 0 of that shape.

4. If x is zero, u is executed on the entire y, (1+#y) times.

### Use These Combinations

Combinations using x u\. y that have exceptionally good performance include:

 What it does Type; Precisions; Ranks Syntax Variants; Restrictions Benefits; Bug Warnings Bitwise reduction and scan integer x (m b.)/ y m is 16 to 31 /\ /\. in place of / much faster than alternatives