One of the things I have been missing in CL was convenient indexing for sub-arrays. Languages like R and Octave all have convenient sub-array indexing. I have experimented with various designs before (some of them I made public, eg AFFI and xarray), but none of them were entirely satisfactory and I kept searching for new solutions.

This is primarily an issue of syntactic convenience: I want to be able to select elements from arrays without writing (nested) loops. I also want to be able to copy elements from arrays to other arrays, similarly selected. Speed is welcome, but at this stage it is secondary: so far, profiling indicates that these operations comprise a tiny fraction of execution time in my programs, but having the ability to capture operations using (sub)arrays is an enormous timesaver and an invaluable semantic abstraction.

## Introduction to `sub`

My latest attempt at tackling this problem is the generic function
`sub`

in my cl-num-utils library (BTW, this library is the successor
of my earlier cl-numlib, which is now deprecated, all useful
functionality will end up in other libraries, eventually). The syntax
is as follows: `(sub object &rest ranges)`

. Each **range** is either a
`fixnum`

(selecting a single index), `(cons start end)`

(selecting
indexes in that range, excluding `end`

as is usually done for CL
library functions), `t`

for all indexes, and finally, a vector of
fixnums for anything else.

Let's see some examples:

CLNU> (defparameter *a* #2A((1 2 3 4) (5 6 7 8) (9 10 11 12))) *A* CLNU> *a* #2A((1 2 3 4) (5 6 7 8) (9 10 11 12)) CLNU> (sub *a* 1 t) ; second row #(5 6 7 8) CLNU> (sub *a* '(1 . 2) t) ; second row as matrix #2A((5 6 7 8))

Notice how a single fixnum will drop that dimension (making a vector
from a matrix), while selecting the same row with a `cons`

doesn't.

For all other cases, you can use vectors:

CLNU> (sub *a* t #(0 3)) ; first and last columns #2A((1 4) (5 8) (9 12)) CLNU> (sub *a* t #(3 0)) ; last and first columns #2A((4 1) (8 5) (12 9))

You can also use negative numbers for indexes: if `(minusp index)`

, it
will select the column `(- dimensions index)`

:

CLNU> (sub *a* -1 t) ; last row #(9 10 11 12) CLNU> (sub *a* #(-2 -1) #(-2 -1)) ; bottom right 2x2 matrix #2A((7 8) (11 12))

Finally, `0`

in a `cons`

corresponds to the largest possible index in
that dimension:

CLNU> (sub *a* '(-2 . 0) t) ; last two rows #2A((5 6 7 8) (9 10 11 12))

## Setting subarrays

`sub`

can also be used with `setf`

:

CLNU> *a* #2A((1 2 3 4) (5 6 7 8) (9 10 11 12)) CLNU> (setf (sub *a* 1 t) #(-1 -2 -3 -4)) ; replace second row #(-1 -2 -3 -4) CLNU> *a* #2A((1 2 3 4) (-1 -2 -3 -4) (9 10 11 12)) CLNU> (setf (sub *a* 2 t) (map 'vector #'+ (sub *a* 0 t) (sub *a* 1 t))) #(0 0 0 0) CLNU> *a* #2A((1 2 3 4) (-1 -2 -3 -4) (0 0 0 0))

Note that the ranks have to be equal, make sure that you keep/drop dimensions as needed.

## Macros for implementing `sub`

In `cl-num-utils`

, you also find the macro `with-range-indexing`

,
which preprocesses the range arguments and implements an internal
counter for row-major indexing. For example, `sub`

for arrays is
implemented as

(defmethod sub ((array array) &rest ranges) (declare (optimize debug (speed 0))) (with-range-indexing (ranges (array-dimensions array) next-index :end? end? :range-dimensions dimensions) (let ((result (make-array (coerce dimensions 'list) :element-type (array-element-type array)))) (iter (until end?) (for result-index :from 0) (setf (row-major-aref result result-index) (row-major-aref array (next-index)))) result)))

The macro takes the range specification as the `ranges`

argument, and
also needs the original dimensions of the array. `next-index`

should
be the name of the function that will be used to query the next index:
it increments the internal counter and delivers the next index. The
internal counter is an array of fixnums, and the index is calculated
with an affine mapping, but the algorithm allows to update the sum
only for the indexes which actually changed. All this is hidden by
the macro. `end?`

is a boolean, which can be used to query when all
the elements have been traversed. `dimensions`

will be bound to the
dimensions of the result, after allowing for dimension droppings.

This macro is pretty versatile: I used it in LLA to implement `(sub dense-matrix-like ...)`

, `((setf sub) array dense-matrix-like ...)`

and `((setf sub) dense-matrix-like array ...)`

methods, even though
LLA is column-major. The trick is to swap dimensions.