Index Generator
 This page is about generating indices for an array of a given size. See Indexing, Indices, Index of, and Interval Index for other operations named after indices.
⍳

Index Generator (⍳
) or Interval, often called by the name of its glyph Iota, is a monadic primitive function which returns an array of indices with shape given by the right argument. In the result, the element at each index is that index.
Originally, Iota was defined only on a single number. In APL/360, and all later APLs, ⍳l
for a scalar l
returns a simple numeric vector of length l
counting from the index origin up. In nested APLs, this result may be seen as an array of scalar indices; NARS extended Iota to allow a vector argument by making the result for a nonsingleton vector be an array of vector indices. Flat APLs do not use this extension, but may extend to multiple argument elements in different ways. A Dictionary of APL defines Iota to have function rank 0, and SHARP APL gives it rank 1 but requires each row (1cell) of the argument to have length 1. In A+ and J Iota of a vector returns an array which counts up in ravel order, that is, it matches Iota of its bound, reshaped. A+ refers to this function as Interval while J calls it Integers.
Examples
⍳n
returns the first n
indices in order:
⍳ 5 1 2 3 4 5
This result depends on index origin: if the index origin is set to zero, it starts counting from zero instead:
⎕IO ← 0 ⍳ 5 0 1 2 3 4
An argument of 0
produces the empty vector, Zilde:
⍳ 0 ⍬ ≡ ⍳ 0 1
Vector arguments
In A+ and J, Iota always returns a simple array. The equivalence ⍳V
V⍴⍳×/V
defines the result for nonsingleton vectors. If the argument is an empty vector, the result is a scalar: the index origin (which is always 0 in these languages).
⍳ 2 3 4 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 ⍳ 0⍴0 0
We might call such a function a "ravel index generator" since the result is an array of scalar indices into its own ravel. In contrast, nested APLs, if they implement Iota for a vector argument (APL2 and APLX, for example, do not), use indices of elements:
⍳ 2 5 ┌───┬───┬───┬───┬───┐ │1 1│1 2│1 3│1 4│1 5│ ├───┼───┼───┼───┼───┤ │2 1│2 2│2 3│2 4│2 5│ └───┴───┴───┴───┴───┘ ⍳⍬ ┌┐ ││ └┘ (⊂⍬) ≡ ⍳⍬ 1
The result of ⍳⍬
should have shape ⍬
, implying it is a scalar, and its only element must be the only possible index into a scalar, the empty vector. This means it must be ⊂⍬
. However, Dyalog APL returned the scalar ⎕IO
instead prior to version 13.0.
Negative arguments
Two languages extend Iota to allow negative arguments. In both cases, the shape of the result is the absolute value of the argument.
In the nested APL NARS2000, negating one number in the argument subtracts that value from each index along the corresponding axis.
⍳2 ¯3 1 ¯2 1 ¯1 1 0 2 ¯2 2 ¯1 2 0
⎕FEATURE[⎕IO]←1
In J, a negative number reverses the result along that axis.
i. 2 _3 2 1 0 5 4 3
Scalarvector discrepancy in nested APLs
In NARS and later nested APLs which share its definition, the result of Iota is simple when the argument is a singleton and nested otherwise. This is because, when the argument is a singleton, each index in the result is represented as a scalar rather than a 1element vector. dzaima/APL breaks from this definition by using vector indices whenever the argument is a vector, and scalar indices if the argument is a scalar, so that the result is only simple if the argument was scalar. This definition has the property that the shape of each index matches the shape of the argument.
Such an extension breaks compatibility with earlier nonnested APLs: although these APLs required the argument of Iota to be a singleton, they always allowed a scalar or vector, and sometimes any singleton. This is because a shape to be passed to Iota would often naturally be a vector: for example, Shape always returns a vector, and a function such as Tally to return a scalar length did not exist.
NARS defines its extension using the equivalence ⍳R
⊃∘.,/⍳¨R
based on an Outer Product reduction. For a singleton vector R
, this does yield a simple result, because ∘.,/
leaves a singleton argument unchanged. However, this is arguably due to inconsistent design in Reduce: NARS's creator, Bob Smith, argues that Catenate reduction should yield a DOMAIN ERROR, and the same arguments apply to its Outer Product.^{[1]}
History
The Greek letter iota, corresponding to the Latin letter i, now usually treated as a mnemonic for "integers" or "index", more likely stood for "identity" in early Iverson notation. Iverson's 1960 paper The Description of Finite Sequential Processes states that "the identity permutation vector is defined by the relation ."^{[2]} Since is a more typical letter to use for the identity permutation, it's possible that Iverson's choice was also motivated by the convention of using for an inclusion map, where iota now indicates "inclusion" or "injection".^{[3]} The term "inclusion" typically indicates that a particular injection is meant to be treated as an identity.
The notation , "Interval", was used in A Programming Language for the vector of the first indices starting at index origin . Both arguments were optional, with being implied by conformability if omitted. It was adopted with the obvious alterations in APL\360, and extended to a vector argument for nested APLs by NARS and for flat arrays by A+.
Outside of APL
The name "iota" has sometimes been used to indicate an increasing sequence of integers even in languages other than APL. In the C++11 standard library, std::iota()
fills an iterator with such a sequence, and was named after the APL glyph.^{[4]}^{[3]}^{[5]} The Go language also uses the name iota
as a predeclared identifier which represents increasing integers: each time it is used within a single constant declaration its value will be one higher.^{[6]} The popular Scheme list library SRFI 1 also includes a function called iota
in reference to APL, which takes a count as well as optional starting value (default 0) and step size (default 1) arguments.^{[7]} The ArrayFire library for generalpurpose computing on graphics processing units has an iota
function with a result similar to that of A+ and J when given a vector argument.^{[8]}
See also
External links
Tutorials
Documentation
References
 ↑ Smith, Bob. "Reduction of Singletons". Minnowbrook 2010.
 ↑ Ken Iverson. The Description of Finite Sequential Processes. Proceedings of a Conference on Information Theory, C. Cherry and W. Jackson, Editors, Imperial College, London, 19600829.
 ↑ ^{3.0} ^{3.1} Sean Parent. "#iotashaming". seanparent.stlab.cc. 20190104.
 ↑ cppreference.com. std::iota. Retrieved 20200428.
 ↑ Rob Mayoff. Answer to "What does iota of std::iota stand for?" on Stack Overflow. Retrieved 20200428.
 ↑ The Go Programming Language Specification. Iota. 20200114.
 ↑ Olin Shivers. SRFI 1: List Library. Finalized 19991009.
 ↑ ArrayFire: Functions. iota. Jun 2, 2015.