Vocabulary/ico

 i: y Steps

Rank 0 -- operates on individual atoms of y, producing a result that may require fill -- WHY IS THIS IMPORTANT?

Like Integers (i.), except that the sequence ranges from (-y) thru (+y).

```   i: 4
_4 _3 _2 _1 0 1 2 3 4

i: _4
4 3 2 1 0 _1 _2 _3 _4
```

1. i: y operates on each atom of y independently, and produces a list for each one.

2. If y is a complex number a+bi (ajb or a j. b in J notation), its imaginary part b gives the number of steps between -a and a i.e. the result will contain b+1 atoms. In this case a may be any number.

3. If y has no imaginary part or the imaginary part is 0, the size of each step is 1. In this case y must be an even multiple of 0.5 (using tolerant comparison).

 x i: y Index Of Last

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

Like Index Of (i.), except that it finds the last occurrence not the first.

```   'abracadabra' i: 'a'
10

'abracadabra' i: 'abc'   NB. several search terms at once
10 8 4
```

If the item is not found, the result is still #x, same as for x i. y.

Related Primitives

Index Of (x i. y)

1. x i: y is a member of the i.-family.

2. The internal rank of  x i: y uses items whose rank is the rank of items of x.

3. If x and y are of different classes, or if their items couldn't possibly match because of differing shapes, no error is signaled: each search simply fails to match.

Use These Combinations

Combinations using x i: y that have exceptionally good performance include:

 What It Does Type; Precisions; Ranks Syntax Primitives permitted in place of f Variants; Restrictions Benefits; Bug Warnings Find last place where  x f y is true Permitted: Boolean, integer, floating point, byte, symbol (not unicode). x and y need not be the same precision. x (f i: 1:) y x i:&1@:f y = ~: < <: > >: e. Permitted: (f!.0) (parentheses obligatory!) to force exact comparison. J recognizes FLO only if f returns an atom or list. Avoids computing entire  x f y Bug warning: if f is e. it does (,@e.) rather than e. regardless of ranks of arguments Find last place where  x f y is false x (f i: 0:) y x i:&0@:f y = ~: < <: > >: e.
 What it does Type; Precisions; Ranks Syntax Variants; Restrictions Benefits; Bug Warnings Find first/last match m&i. y i: in place of i. for last match !.0 for exact comparison Find index of first/last cell of y that does/does not match an m-item (e. i. 1:)&m y i: in place of i. for last cell 0: for mismatch Bug warning: it does (,@e.) rather than e. Find index of first/last occurrence of largest/smallest value integer or floating-point list (i. <./) y (i. >./) y or i: it actually does (i. >.!.0/) etc.; is faster than 0 ({ /:~) y