# Vocabulary/ico

>>
<< ` `
Down to: Dyad ` `
Back to: Vocabulary
Thru to: Dictionary

`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

### More Information

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* (`a``j`* b* 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`)

### More Information

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 argumentsFind 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 comparisonFind 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`