Vocabulary/bslash
>> << Down to: Dyad Back to: Vocabulary Thru to: Dictionary
u\ y Prefix Adverb
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 prefixes of list y of increasing length (1, 2, 3, ...)
]\ 'banana' b ba ban bana banan banana
The main use is the form u/\
+/\ 1 2 3 4 5 6 NB. compute running total 1 3 6 10 15 21
If you want to use u/\ y with a u that is not a primitive, consider using Suffix (\.) instead.
Common Uses
u\ y is magic when u is of the form u/. Look what happens then:
u =: dyad define NB. This verb shows what the operands of u are x , ' u ' , y ) u/\ 'abcdef' a a u b a u b u c a u b u c u d a u b u c u d u e a u b u c u d u e u f
u gets applied between larger and larger prefixes of y. The effect is of a loop, when on each iteration one more item of y in operated on.
Let's look at a concrete example. Suppose u is +
plus =: dyad define x , ' + ' , y ) plus/\ 'abcdef' a a + b a + b + c a + b + c + d a + b + c + d + e a + b + c + d + e + f
Get the idea? The operand u is applied between longer and longer prefixes of y. It's a loop that reports the results of each iteration.
1. To make a running sum of the items of y
+/\ 1 2 3 4 5 1 3 6 10 15
2. To create the running maximum, i.e. the maximum value encountered so far at each point in a list
>./\ 3 1 4 1 5 9 2 6 3 3 4 4 5 9 9 9
3. To count the parity at each point in a list, i.e. whether the items up to and including each item contain an odd number of 1s
~:/\ 1 0 0 1 1 0 1 0 1 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 1 1
4. When y has exactly 2 items, u/\y is a good way to replace the second item with a function of y while leaving the first item unchanged.
Example: suppose the atoms of y represent the starting index of a substring and the ending index plus one. You can then convert easily to (start,length) form
]startend =: ; ('<td';'</td') I.@:E. each <'This is HTML.<td>It is table cells.</td>Extract one.'
13 35
]startlen =: -~/\ startend
13 22
More Information
1. Normally you will not use u/\ with non-primitive u unless you know that y is short. The reason can be seen by examining the order of evaluation of the successive prefixes
u =: dyad define NB. This verb shows the arguments of u
'(' , x , ' u ' , y , ')'
)
u/\ 'abcdef'
a
(a u b)
(a u (b u c))
(a u (b u (c u d)))
(a u (b u (c u (d u e))))
(a u (b u (c u (d u (e u f)))))
The ugly fact disclosed here is that each row does not use the result of the previous row. The computation is not incremental at all: each row has to be computed separately, with the computation taking longer and longer as the prefix gets longer.
If J knew that u is associative, it could reorder the computation to be incremental. J knows it for primitives, hence those are fast. But, for more general u , J must assume the worst case.
To avoid this problem you should use Suffix (u\. y).
2. The first item of y is not changed by u/\ y . (It could be changed by general 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;
RanksSyntax Variants;
Restrictions
Benefits;
Bug Warnings
Concatenated running totals on intervals (running total, but total is reset at start of each interval) ;@:(<@(f/\);.n) y
x ;@:(<@(f/\);.n) y
(f is any verb)n e. _2 _1 1 2; also [: ; (f... also <@:(f/\); also <@: Bitwise reduction and scan integer x (m b.)/ y
m is 16 to 31
/\ /\. in place of / much faster than alternatives Create list of integers from 1 to # y, or the reverse #\ y also #\. which is the reverse faster than >:@i.@# y
x u\ y Infix Adverb
Rank 0 _ -- operates on atoms of x, and the entirety of y -- WHY IS THIS IMPORTANT?
(x u\y) applies verb u to successive parts of list y (called infixes).
1. If x is positive, u is applied to every infix of x items of y (the infixes may overlap)
3 <\ 'abcdefg' +---+---+---+---+---+ |abc|bcd|cde|def|efg| +---+---+---+---+---+
2. If x is negative, the first infix comprises the first |x items; subsequent infixes do not overlap but do include all items of y, which means that the last infix may be short
_3 <\ 'abcdefg' +---+---+-+ |abc|def|g| +---+---+-+
Common uses
1. Reshape a list into a table of width 2
More convenient than ($) -- avoids discovering the length of the list.
x=: _2 NB. width is 2, negate to get non-overlapping rows x ]\ 'abcde' NB. here it pads with spaces ab cd e x ]\ i.5 NB. here it pads with zeros 0 1 2 3 4 0 x ]\ 'Fred';10;'John';20;'Eva';30 NB. can handle boxed list +----+--+ |Fred|10| +----+--+ |John|20| +----+--+ |Eva |30| +----+--+
Example: A handy utility to reshape into rows of width x (=2 by default)
listx=: 2&$: :(] ]\~ [: - [) listx i.5 NB. use (:) and ($:) to default x to 2 0 1 2 3 4 0 10 listx i.30 0 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 28 29
2. Chop a list into boxes of pairs of items
(Same principle as 1. above, but replaces (]) with (<)
x=: _2 x <\ 'abcde' +--+--+-+ |ab|cd|e| +--+--+-+
3. Perform an operation on successive pairs of items
x=: 2 NB. NOT negated because you want overlapping pairs x +/\ 3 1 4 1 5 9 NB. Sum successive pairings: (3 1), (1 4), (4 1), etc. 4 5 5 6 14
4. Chop a long string into a table that fits on the screen
]s =: 200 $ 'Lorem ipsum dolor sit amet, consectetur adipisicing elit,' Lorem ipsum dolor sit amet, consectetur adipisicing elit,... _50 ]\ s Lorem ipsum dolor sit amet, consectetur adipisicin g elit,Lorem ipsum dolor sit amet, consectetur adi pisicing elit,Lorem ipsum dolor sit amet, consecte tur adipisicing elit,Lorem ipsum dolor sit amet, c
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 a single infix for a positive x, the result of x u\ y will also have no items. However, u will be executed once on a cell of fills 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. The shape of the cell of fills depends on whether x is positive or negative.
- If x is positive, u is designed to see cells only with x items, and the cell of fills will have that shape
- If x is negative, u must be prepared for cells of varying size, and the cell of fills will have 0 items
$ _3 ]\ i. 0 3 NB. Negative x, fill cell is shape 0 3 0 0 3 $ 3 ]\ i. 0 3 NB. Positive x, fill cell is shape 3 3 0 3 3
4. If x is zero, u is executed on an empty cell, (1+#y) times.
Use These Combinations
Combinations using x u\ y that have exceptionally good performance are shown in Special Combinations: Infixes.