index operator
Syntax
float/string/bool        array[index]
float/string/bool        array[rowIndex,   colIndex  ]
float[]/string[]/bool[]  array[indices]
float[]/string[]/bool[]  array[rowIndex,   colIndices]
float[]/string[]/bool[]  array[rowIndices, colIndex  ]
float[]/string[]/bool[]  array[rowIndices, colIndices]
Parameters
- array (float[], string[], bool[])
Array for which an element or multiple elements are requested. - index, rowIndex, colIndex (float)
Zero-based linear/row/column index of array element. - indices, rowIndices, colIndices (float[], bool[])
Array containing zero-based linear/row/column indices of array elements or logical values indicating whether a specific index is included.
Returns
An array element or a new array.Description
Indexing with index values
The index operator returns the array element at a specific zero-based index position:
array = |
[1,2,3,4] |
array[ 0 ] |
1 |
array[ 3 ] |
4 |
or the element at a specific rowIndex (row index) and colIndex (column index):
array2d = |
[1,2,3; 4,5,6; 7,8,9] |
array2d[ 1 , 1 ] |
5 |
Indexing with index arrays
Further, array elements can be indexed by an array (indices, rowIndices, colIndices). In this case the index operator returns a new array. Its dimensions are prescribed by the dimensions of the indices array.
array[ [0,2] ] |
[1,3] |
array[ [1,1] ] |
[2,2] |
array[ 3:-1:1 ] |
[4,3,2] |
array[ [0,1; 2,3] ] |
[1,2; 3,4] |
array2d[ 1 , [0,2] ] |
[4,6] |
array2d[ [0,0,1] , 2 ] |
[3; 3; 6] |
array2d[ 0:2 , [0,2] ] |
[1,3; 4,6; 7,9] |
Logical indexing
An indices array (indices, rowIndices, colIndices) can also be given by logical values indicating whether a specific index is included:
array[ [true,false,true] ] |
[1,3] |
array[ array .> 2 ] |
[3,4] |
array[ array .> 1 .&& array .<= 3 ] |
[2,3] |
array2d[ [false,true,true], 0 ] |
[4; 7] |
Invalid indexing
If an index is negative or greater than or equal to the number of elements or rows or columns respectively, a default value is returned. The default value is 0 for float arrays, false for bool arrays, and "" for string arrays.
array[ -1 ] |
0 |
array[ [false,false,true,true,true] ] |
[3,4,0] |
array2d[ [2,3], -1:1 ] |
[0,7,8; 0,0,0] |
Linear indexing
If a 2d array is indexed in 1d, linear indexing is used. Indexing is performed row-wise starting with elements in the first row and continuing on successive rows.
array2d[ 3 ] |
4 |
array2d[ 0 : size(array2d)-1 ] |
[0,1,2,3,4,5,6,7,8,9] |
array2d[ [0; 3; 6] ] |
[1; 4; 7] |
Similarly, if a 2d indices array is used for row/column indexing, indices in rowIndices or colIndices are interpreted in a row-wise manner.
array2d[ 0 , [0,1; 2,3] ] |
[1,2,3,0] |
Logical indexing is always linear.
array[ [true,false; true,false] ] |
[1,3] |
Related
- Array types operators
- array initialization function
- size function
- nRows function
- nColumns function
- setElems function
Examples
Recursive element selection
indexOfLargest(array) = indexOfLargest(array, 0, 0) indexOfLargest(array, i, iLargest) = case i == size(array) : iLargest else : case array[i] > array[iLargest] : indexOfLargest(array, i+1, i) else : indexOfLargest(array, i+1, iLargest) const edgeLengths = comp(e) { all : scope.sx } indexOfLongestEdge = indexOfLargest(edgeLengths) Lot --> comp(e) { indexOfLongestEdge : LongestEdge. }With the size function and index operator an array can be recursively parsed for a specific element value. In this example the index of the longest edge is retrieved from an array of edge lengths.
Parsing text file
// table // a;b;c↵ // d;e;f↵ // g;h;i const file = readTextFile("table.txt") const cells = splitString(file, "$;|\n") // [a,b,c,d,e,f,g,h,i] const columns = 3 const indexes = [0 : columns : size(cells)-1] // [0:3:6] const firstCol = cells[indexes] // [a,d,g]A text file containing a table is parsed and elements are indexed linearly.
Read CSV table
const table = readStringTable("table.csv") const firstCol = table[0 : nRows(table)-1, 0] // [a,d,g]A CSV file is read and elements are indexed using the 2d index operator.
Indexing by 2d arrays
const a = ["_", "d", "i", "a", "g"] const b = [1,0,0,0; 0,2,0,0; 0,0,3,0; 0,0,0,4] const c = a[b] // (4x4) // d _ _ _ // _ i _ _ // _ _ a _ // _ _ _ gThe result of the 1d index operator is an array that has the same dimensions as the indices array.
Indexing out of bounds
zeros(elems) = floatArray[1:elems] ones(rows,cols) = floatArray[1:rows,1:cols] .+ 1 const a = zeros(4) // [0,0,0,0] const b = ones(2,3) // [1,1,1 ; 1,1,1]An empty floatArray is indexed by index sequences. This creates a new array filled with default values (which is zero for float).
Prime numbers
findPrimes(max) = case max <= 1 : floatArray else : findPrimes(sqrt(max), [2 : max], floatArray) findPrimes(limit, a, primes) = case a[0] <= limit : findPrimes(limit, a[a .% a[0] .!= 0], [primes, a[0]]) else : [primes, a] Lot --> print(findPrimes(20)) // (8)[2,3,5,7,11,13,17,19]An implementation of the Sieve of Eratosthenes that uses indexing by boolean arrays.
Copyright ©2008-2024 Esri R&D Center Zurich. All rights reserved.