Indexed access to arrays and tables without evaluation
This functionality does not run in MATLAB.
indexval(x
,i
) indexval(x, i1, i2, …
)
indexval(x, i)
and indexval(x, i1,
i2, ...)
yields the entry of x
corresponding
to the indices i
and i1, i2, ...
,
respectively, without evaluation.
The three calls indexval(x, i)
, _index(x,
i)
, and x[i]
all return the element of
index i
in the array or hfarray or list or table x
. In contrast
to _index
and
the equivalent index operator [ ]
, however, indexval
returns
the corresponding entry without evaluating it. This is sometimes desirable
for efficiency reasons.
The arguments i
or i1, i2, ... must be a
valid indices of x
, otherwise an error message
is printed (see Example 3).
When several indices i1, i2, ... are given, they are interpreted as
a higherdimensional index (see Example 4).
The first argument x
may also be a set, a string,
or an expression sequence. However,
in these cases indexval
behaves exactly like _index
and the index
operator [ ]
: it returns the evaluation
of the corresponding element. In particular, indexval
does
not flatten its
first argument.
For all other basic domains, indexval
behaves
exactly like _index
:
either an error occurs, or a symbolic indexval
call
is returned (see Example 3).
indexval
works with tables:
T := table("1" = a, Be = b, `+` = a + b): a := 1: b := 2: indexval(T, Be), indexval(T, "1"), indexval(T, `+`)
In contrast _index
evaluates
returned entries:
_index(T, Be), _index(T, "1"), _index(T, `+`)
The next input line has the same meaning as the last:
T[Be], T["1"], T[`+`]
indexval
works with arrays, too. The behavior
is the same, but the indices must be positive integers:
delete a, b: A := array(1..2, 1..2, [[a, a + b], [a  b, b]]): a := 1: b := 2: indexval(A, 2, 2), indexval(A, 1, 1), indexval(A, 1, 2)
_index(A, 2, 2), _index(A, 1, 1), _index(A, 1, 2)
A[2, 2], A[1, 1], A[1, 2]
delete A, T, a, b:
indexval
works lists, too:
delete a, b: L := [a, b, 2]: b := 5: L[2], _index(L, 2), indexval(L, 2), op(L, 2)
However, there is no difference between indexval
and _index
for all other
valid objects, e.g., sets:
delete a, b: S := {a, b, 2}: b := 5: S[2], _index(S, 2), indexval(S, 2), op(S, 2)
Similarly, there is no difference when the first argument is
an expression sequence (which is not flattened by indexval
):
delete a, b: S := a, b, 2: b := 5: S[2], _index(S, 2), indexval(S, 2), op(S, 2)
delete L, S, a, b:
If the second argument is not a valid index, an error occurs:
A := array(1..2, 1..2, [[a, b], [a, b]]): indexval(A, 3)
Error: Index dimension mismatch. [array]
indexval(A, 1, 0)
Error: The argument is invalid. [array]
indexval("12345", 6)
Error: The index is invalid. [string]
However, the result of indexval
can also
be a symbolic indexval
call:
T := table(1 = a, 2 = b): indexval(T, 3)
delete X, i: indexval(X, i)
delete A, T:
For arrays the number of indices must be equal to the number of dimensions of the array:
A := array(1..2, 1..2, [[a, b], [a, b]]): a := 1: b := 2: indexval(A, 1, 2), indexval(A, 2, 1)
Otherwise an error occurs:
indexval(A, 1)
Error: Index dimension mismatch. [array]
Tables can have expression sequences as indices, too:
delete a, b: T := table((1, 1) = a, (2, 2) = b): a := 1: b := 2: indexval(T, 1, 1), indexval(T, 2, 2)
delete A, T, a, b:

Essentially a table, a list, or an array. Also allowed: a hfarray, a finite set, an expression sequence, or a character string 

Indices. For most "containers" 
Entry of x
corresponding to the index. When x
is
a table, a list or an array, the returned entry is not evaluated again.
x