Index Generator: Difference between revisions
m (→Outside of APL) 

(4 intermediate revisions by the same user not shown)  
Line 2:  Line 2:  
{{BuiltinIndex Generator⍳}} or '''Interval''', often called by the name of its [[glyph]] '''Iota''', is a [[monadic]] [[primitive function]] which returns an array of [[indexindices]] with [[shape]] given by the right [[argument]]. In the result, the [[element]] at each [[index]] is that index.  {{BuiltinIndex Generator⍳}} or '''Interval''', often called by the name of its [[glyph]] '''Iota''', is a [[monadic]] [[primitive function]] which returns an array of [[indexindices]] 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, <  Originally, Iota was defined only on a single number. In [[APL/360]], and all later APLs, <syntaxhighlight lang=apl inline>⍳l</syntaxhighlight> for a [[scalar]] <syntaxhighlight lang=apl inline>l</syntaxhighlight> returns a [[simple]] [[numeric]] [[vector]] of length <syntaxhighlight lang=apl inline>l</syntaxhighlight> counting from the [[index origin]] up. In [[Nested array theorynested]] 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 non[[singleton]] vector be an array of vector indices. [[Flat array theoryFlat]] 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 (1[[cell]]) 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]], [[reshape]]d. A+ refers to this function as '''Interval''' while J calls it '''Integers'''.  
== Examples ==  == Examples ==  
<  <syntaxhighlight lang=apl inline>⍳n</syntaxhighlight> returns the first <syntaxhighlight lang=apl inline>n</syntaxhighlight> [[indexindices]] in order:  
<  <syntaxhighlight lang=apl>  
⍳ 5  ⍳ 5  
1 2 3 4 5  1 2 3 4 5  
</  </syntaxhighlight>  
This result depends on [[index origin]]: if the index origin is set to zero, it starts counting from zero instead:  This result depends on [[index origin]]: if the index origin is set to zero, it starts counting from zero instead:  
<  <syntaxhighlight lang=apl>  
⎕IO ← 0  ⎕IO ← 0  
⍳ 5  ⍳ 5  
0 1 2 3 4  0 1 2 3 4  
</  </syntaxhighlight>  
An argument of <  An argument of <syntaxhighlight lang=apl inline>0</syntaxhighlight> produces the [[empty]] [[vector]], [[Zilde]]:  
<  <syntaxhighlight lang=apl>  
⍳ 0  ⍳ 0  
⍬ ≡ ⍳ 0  ⍬ ≡ ⍳ 0  
1  1  
</  </syntaxhighlight>  
=== Vector arguments ===  === Vector arguments ===  
In [[A+]] and [[J]], Iota always returns a [[simple]] array. The equivalence <  In [[A+]] and [[J]], Iota always returns a [[simple]] array. The equivalence <syntaxhighlight lang=apl inline>⍳V</syntaxhighlight> {{←→}} <syntaxhighlight lang=apl inline>V⍴⍳×/V</syntaxhighlight> 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).  
<  <syntaxhighlight lang=apl>  
⍳ 2 3 4  ⍳ 2 3 4  
0 1 2 3  0 1 2 3  
Line 39:  Line 39:  
⍳ 0⍴0  ⍳ 0⍴0  
0  0  
</  </syntaxhighlight>{{Works in[[A+]]}}  
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 array theorynested]] APLs, if they implement Iota for a vector argument ([[APL2]] and [[APLX]], for example, do not), use [[indexindices]] of [[element]]s:  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 array theorynested]] APLs, if they implement Iota for a vector argument ([[APL2]] and [[APLX]], for example, do not), use [[indexindices]] of [[element]]s:  
<  <syntaxhighlight lang=apl>  
⍳ 2 5  ⍳ 2 5  
┌───┬───┬───┬───┬───┐  ┌───┬───┬───┬───┬───┐  
Line 54:  Line 54:  
(⊂⍬) ≡ ⍳⍬  (⊂⍬) ≡ ⍳⍬  
1  1  
</  </syntaxhighlight>{{Works in[[NARS]], [[NARS2000]], [[Dyalog APL]], [[GNU APL]], [[ngn/apl]], [[dzaima/APL]]}}  
The result of <  The result of <syntaxhighlight lang=apl inline>⍳⍬</syntaxhighlight> should have [[shape]] <syntaxhighlight lang=apl inline>⍬</syntaxhighlight>, 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 <syntaxhighlight lang=apl inline>⊂⍬</syntaxhighlight>. However, [[Dyalog APL]] returned the scalar <syntaxhighlight lang=apl inline>⎕IO</syntaxhighlight> instead prior to [[Dyalog APL 13.0version 13.0]].  
=== Negative arguments ===  === Negative arguments ===  
Line 62:  Line 62:  
In the [[nested array theorynested]] APL [[NARS2000]], negating one number in the argument subtracts that value from each index along the corresponding [[axis]].  In the [[nested array theorynested]] APL [[NARS2000]], negating one number in the argument subtracts that value from each index along the corresponding [[axis]].  
<  <syntaxhighlight lang=apl>  
⍳2 ¯3  ⍳2 ¯3  
1 ¯2 1 ¯1 1 0  1 ¯2 1 ¯1 1 0  
2 ¯2 2 ¯1 2 0  2 ¯2 2 ¯1 2 0  
</  </syntaxhighlight>{{Works in[[NARS2000]], <syntaxhighlight lang=apl inline>⎕FEATURE[⎕IO]←1</syntaxhighlight>}}  
In [[J]], a negative number [[reverse]]s the result along that axis.  In [[J]], a negative number [[reverse]]s the result along that axis.  
<  <syntaxhighlight lang=j>  
i. 2 _3  i. 2 _3  
2 1 0  2 1 0  
5 4 3  5 4 3  
</  </syntaxhighlight>{{Works in[[J]]}}  
== Scalarvector discrepancy in nested APLs ==  == Scalarvector discrepancy in nested APLs ==  
Line 81:  Line 81:  
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.  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 <  [[NARS]] defines its extension using the equivalence <syntaxhighlight lang=apl inline>⍳R</syntaxhighlight> {{←→}} <syntaxhighlight lang=apl inline>⊃∘.,/⍳¨R</syntaxhighlight> based on an [[Outer Product]] [[reduction]]. For a singleton vector <syntaxhighlight lang=apl inline>R</syntaxhighlight>, this does yield a simple result, because <syntaxhighlight lang=apl inline>∘.,/</syntaxhighlight> 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.<ref>[[Bob SmithSmith, Bob]]. [http://www.sudleyplace.com/APL/Reduction%20Of%20Singletons.pdf "Reduction of Singletons"]. [[Minnowbrook]] 2010.</ref>  
== History ==  == History ==  
Line 92:  Line 92:  
The name "iota" has sometimes been used to indicate an increasing sequence of integers even in languages other than APL:  The name "iota" has sometimes been used to indicate an increasing sequence of integers even in languages other than APL:  
* The [[wikipedia:C++C++11]] standard library has <  * The [[wikipedia:C++C++11]] standard library has <syntaxhighlight lang=c++ inline>std::iota()</syntaxhighlight> fills an iterator with such a sequence, and was named after the APL glyph.<ref>cppreference.com. [https://en.cppreference.com/w/cpp/algorithm/iota std::iota]. Retrieved 20200428.</ref><ref name="iotashaming"/><ref>Rob Mayoff. [https://stackoverflow.com/a/9244949 Answer to "What does iota of std::iota stand for?"] on Stack Overflow. Retrieved 20200428.</ref>  
* The [[wikipedia:Go (programming language)Go]] language also uses the name <  * The [[wikipedia:Go (programming language)Go]] language also uses the name <syntaxhighlight lang=go inline>iota</syntaxhighlight> as a predeclared identifier which represents increasing integers: each time it is used within a single constant declaration its value will be one higher.<ref>The Go Programming Language Specification. [https://golang.org/ref/spec#Iota Iota]. 20200114.</ref>  
* The popular [[wikipedia:Scheme (programming language)Scheme]] list library SRFI 1 also includes a function called <  * The popular [[wikipedia:Scheme (programming language)Scheme]] list library SRFI 1 also includes a function called <syntaxhighlight lang=scheme inline>iota</syntaxhighlight> in reference to APL, which takes a count as well as optional starting value (default 0) and step size (default 1) arguments.<ref>Olin Shivers. [https://srfi.schemers.org/srfi1/srfi1.html#iota SRFI 1: List Library]. Finalized 19991009.</ref>  
* The [[wikipedia:ArrayFireArrayFire]] library for [[wikipedia:generalpurpose computing on graphics processing unitsgeneralpurpose computing on graphics processing units]] has an <  * The [[wikipedia:ArrayFireArrayFire]] library for [[wikipedia:generalpurpose computing on graphics processing unitsgeneralpurpose computing on graphics processing units]] has an <syntaxhighlight lang=c inline>iota</syntaxhighlight> function with a result similar to that of A+ and J when given a [[#Vector_argumentsvector argument]].<ref>ArrayFire: Functions. [https://arrayfire.org/docs/group__data__func__iota.htm iota]. Jun 2, 2015.</ref>  
* The [[wikipedia:Berkeley Software DistributionBSD]] operating system and its derivatives, for example [[wikipedia:macOSmacOS]], have a <syntaxhighlight lang=shell inline>jot</syntaxhighlight> which can print sequential data. The name <syntaxhighlight lang=shell inline>jot</syntaxhighlight> derives in part from APL's glyph.<ref>openbsd.org. [https://man.openbsd.org/jot#DESCRIPTION jot]. Retrieved 20220804.</ref>  
* The [[wikipedia:JavaScriptJavaScript]] library scijs includes an iotaarray package with the <syntaxhighlight lang=js inline>iota</syntaxhighlight> function.<ref>scijs.not. [https://scijs.net/packages/#scijs/iotaarray iotaarray]. Retrieved 202230511</ref>  
== See also ==  == See also == 
Latest revision as of 07:46, 11 May 2023
 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:
 The C++11 standard library has
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]}  The BSD operating system and its derivatives, for example macOS, have a
jot
which can print sequential data. The namejot
derives in part from APL's glyph.^{[9]}  The JavaScript library scijs includes an iotaarray package with the
iota
function.^{[10]}
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.
 ↑ openbsd.org. jot. Retrieved 20220804.
 ↑ scijs.not. iotaarray. Retrieved 202230511