This SRFI specifies an array mechanism for Scheme. Arrays as defined here are quite general; at their most basic, an array is simply a mapping, or function, from multi-indices of exact integers $i_0,\ldots,i_{d-1}$ to Scheme values. The set of multi-indices $i_0,\ldots,i_{d-1}$ that are valid for a given array form the domain of the array. In this SRFI, each array's domain consists of a rectangular interval $[l_0,u_0)\times[l_1,u_1)\times\cdots\times[l_{d-1},u_{d-1})$, a subset of $\mathbb Z^d$, $d$-tuples of integers. Thus, we introduce a data type called intervals, which encapsulate the cross product of nonempty intervals of exact integers. Specialized variants of arrays are specified to provide portable programs with efficient representations for common use cases.
Requiring the transformations $T_{BA}:D_B\to D_A$ to be affine may seem esoteric and restricting, but in fact many common and useful array transformations can be expressed in this way. We give several examples below:
array-extract to define this common operation; it's like looking at a rectangular sub-part of a spreadsheet. We use it to extract the common part of overlapping domains of three arrays in an image processing example below. array-translate to provide this operation.array-permute for this operation. The only nonidentity permutation of a two-dimensional spreadsheet turns rows into columns and vice versa.array-curry for this operation, which returns an array whose domain is $\text{Int}_1$ and whose elements are themselves arrays, each of which is defined on $\text{Int}_2$. Currying a two-dimensional array would be like organizing a spreadsheet into a one-dimensional array of rows of the spreadsheet.We make several remarks. First, all these operations could have been computed by specifying the particular mapping $T_{BA}$ explicitly, so that these routines, where one specifies the translation $\vec d$ or the permutation $\pi$ or the outer dimension $r$ of $D_A$ (in the currying example) are simply "convenience" procedures. Second, because the composition of any number of affine mappings are again affine, accessing or changing the elements of a restricted, translated, curried, permuted array is no slower than accessing or changing the elements of the original array itself. Finally, we note that by combining array currying and permuting, say, one can come up with simple expressions of powerful algorithms, such as extending one-dimensional tranforms to multi-dimensional separable transforms, or quickly generating two-dimensional slices of three-dimensional image data. Examples are given below.
+array-extract to define this common operation; it's like looking at a rectangular sub-part of a spreadsheet. We use it to extract the common part of overlapping domains of three arrays in an image processing example below. array-translate to provide this operation.array-permute for this operation. The only nonidentity permutation of a two-dimensional spreadsheet turns rows into columns and vice versa.array-curry for this operation, which returns an array whose domain is $\text{Int}_1$ and whose elements are themselves arrays, each of which is defined on $\text{Int}_2$. Currying a two-dimensional array would be like organizing a spreadsheet into a one-dimensional array of rows of the spreadsheet.#f and $i_j\to u_j+l_j-1-i_j$ if $F_j$ is #t.In other words, we reverse the ordering of the $j$th coordinate of $\vec i$ if and only if $F_j$ is true. $T_{BA}$ is an affine mapping from $D_B\to D_A$, which defines a new array $B$, and we can provide array-reverse for this operation. Applying array-reverse to a two-dimensional spreadsheet might reverse the order of the rows or columns (or both).interval-scale and array-sample for these operations.We make several remarks. First, all these operations could have been computed by specifying the particular mapping $T_{BA}$ explicitly, so that these routines are simply "convenience" procedures. Second, because the composition of any number of affine mappings are again affine, accessing or changing the elements of a restricted, translated, curried, permuted array is no slower than accessing or changing the elements of the original array itself. Finally, we note that by combining array currying and permuting, say, one can come up with simple expressions of powerful algorithms, such as extending one-dimensional tranforms to multi-dimensional separable transforms, or quickly generating two-dimensional slices of three-dimensional image data. Examples are given below.
Bawden-style arrays are clearly useful as a programming construct, but they do not fulfill all our needs in this area. An array, as commonly understood, provides a mapping from multi-indices $(i_0,\ldots,i_{d-1})$ of exact integers in a nonempty, rectangular, $d$-dimensional interval $[l_0,u_0)\times[l_1,u_1)\times\cdots\times[l_{d-1},u_{d-1})$ (the domain of the array) to Scheme objects. @@ -67,21 +70,10 @@
One could again "share" $B$, given a new interval $D_C$ as the domain of a new array $C$ and an affine transform $T_{CB}:D_C\to D_B$, and then each access $C(\vec i)=A(T_{BA}(T_{CB}(\vec i)))$. The composition $T_{BA}\circ T_{CB}:D_C\to D_A$, being itself affine, could be precomputed and stored as $T_{CA}:D_C\to D_A$, and $C(\vec i)=A(T_{CA}(\vec i))$ can be computed with the overhead of computing a single affine transformation.
So, if we wanted, we could share generalized arrays with constant overhead by adding a single layer of (multi-valued) affine transformations on top of evaluating generalized arrays. Even though this could be done transparently to the user, we do not do that here; it would be a compatible extension of this SRFI to do so. We provide only the routine specialized-array-share, not a more general array-share.
Certain ways of sharing generalized arrays, however, are relatively easy to code and not that expensive. If we denote (array-getter A) by A-getter, then if B is the result of array-extract applied to A, then (array-getter B) is simply A-getter. Similarly, if A is a two-dimensional array, and B is derived from A by applying the permutation $\pi((i,j))=(j,i)$, then (array-getter B) is (lambda (i j) (A-getter j i)). Translation and currying also lead to transformed arrays whose getters are relatively efficiently derived from A-getter, at least for arrays of small dimension.
Thus, while we do not provide for sharing of generalized arrays for general one-to-one affine maps $T$, we do allow it for the specific functions array-extract, array-translate, array-permute, and array-curry, and we provide relatively efficient implementations of these functions for arrays of dimension no greater than four.
Thus, while we do not provide for sharing of generalized arrays for general one-to-one affine maps $T$, we do allow it for the specific functions array-extract, array-translate, array-permute, array-curry, array-reverse, and array-sample, and we provide relatively efficient implementations of these functions for arrays of dimension no greater than four.
Daniel Friedman and David Wise wrote a famous paper CONS should not Evaluate its Arguments. In the spirit of that paper, our procedure array-map does not immediately produce a specialized array, but a simple immutable array, whose elements are recomputed from the arguments of array-map each time they are accessed. This immutable array can be passed on to further applications of array-map for further processing, without generating the storage bodies for intermediate arrays.
We provide the procedure array->specialized-array to transform a generalized array (like that returned by array-map) to a specialized, Bawden-style array, for which accessing each element again takes $O(1)$ operations.
-(define (vector-field-sequence-ell-infty-ell-1-ell-2-norm p) - (array-max (array-map (lambda (p^k) - (array-average (array-map Point-length-R^4 - (array-extract p^k - (array-domain zero-image))))) - p)))(with suitable definitions for
array-max, array-average, and Point-length-R^4) computes the maximum over a number of two-dimensional arrays of the average length of four-vectors in those arrays restricted to the domain of zero-image, without storing all of the elements of any of the intermediate arrays together.interval-curry),
which don't seem terribly natural for arrays.
(make-array ...), array-map, and array->specialized-array to construct arrays, and while there are several other ways to construct arrays, there is no really low-level interface given for constructing specialized arrays (where one specifies a body, an indexer, etc.). It was felt that certain difficulties, some surmountable (such as checking that a given body is compatible with a given storage class) and some not (such as checking that an indexer is indeed affine), made a low-level interface less useful. At the same time, the simple (make-array ...) mechanism is so general, allowing one to specify getters and setters as general functions, as to cover nearly all needs.This document refers to translations and permutations. - A translation is a vector of exact integers. A permutation of length $n$ + A translation is a vector of exact integers. A permutation of dimension $n$ is a vector whose entries are the exact integers $0,1,\ldots,n-1$, each occuring once, in any order.
Procedure: translation? object
(vector-ref lower-bounds i) and interval-upper-bound returns
(vector-ref upper-bounds i). It is an error to call interval-lower-bound or interval-upper-bound
if interval and i do not satisfy these conditions.
+ Procedure: interval-lower-bounds->list interval
Procedure: interval-upper-bounds->list interval
If interval is an interval built with
(make-interval lower-bounds upper-bounds)
+ then interval-lower-bounds->list returns (vector->list lower-bounds) and interval-upper-bounds->list returns (vector->list upper-bounds). It is an error to call
+ interval-lower-bounds->list or interval-upper-bounds->list if interval does not satisfy these conditions.;;;
Procedure: interval-lower-bounds->vector interval
Procedure: interval-upper-bounds->vector interval
If interval is an interval built with
(make-interval lower-bounds upper-bounds)
then, assuming the existence of vector-map, interval-volume returns