Pass subarray by reference (not by value) in Common Lisp

Question

Let's suppose I have an array - which I will call *my-array* - that looks like this:

#2A((1 2 3)
    (4 5 6)
    (7 8 9))

and I wish to apply some function f on the subarray

#2A((5 6)
    (8 9))

I'd love to be able to write

(f (subarray *my-array* '(1 2) '(1 2))

where subarray takes as arguments:

• the original array
• a 2-element list with starting point and ending point on the 1st dimension
• another 2-element list with starting point and ending point on the 2nd dimension
• etc.

I am looking for some way to pass the subarray as argument to function f by reference (or by pointer?) instead of by value.

(The dumb way to address this would be to write a function that creates (in this specific case) a 2*2 array and loops over i and j copying values from the original array. However, if you are dealing relatively large arrays, this would be quite costly.)

I found there exists a cl-slice package but I do not get whether it copies values or accesses data by reference.

Answer 1

Common Lisp has Displaced Arrays which are exactly what you are asking about (see array-displacement &c).

However, in your case, displaces arrays are no help because:

Multidimensional arrays store their components in row-major order; that is, internally a multidimensional array is stored as a one-dimensional array, with the multidimensional index sets ordered lexicographically, last index varying fastest.

This means that your subarray is not a contiguous section of your main array, and, thus, you cannot create another array displaced to it.

PS. If you cannot figure out how cl-slice works, you can use time to see how much memory it uses and make your inference from that.

PPS. It is, in fact, not too hard to whip up something like what you want:

(defmacro slice (array &rest ranges)
  "Return an accessor into ARRAY randing in RANGES."
  (let ((args (loop for r in ranges collect (gensym "SLICE-ARG-")))
        (arr (gensym "SLICE-ARRAY-")))
    `(let ((,arr ,array))
       (lambda ,args
         (aref ,arr
               ,@(loop for arg in args and (lo hi) in ranges
                   for range = (- hi lo)
                   collect
                     `(progn
                        (unless (<= 0 ,arg ,range)
                          (error "~S is out of range [0;~S]" ,arg ,range))
                        (+ ,lo ,arg))))))))

(defparameter *my-array*
  #2A((1 2 3)
      (4 5 6)
      (7 8 9)))

(defparameter f (slice *my-array* (1 2) (1 2)))

(loop for i from 0 to 1 do
    (loop for j from 0 to 1 do
        (format t " ~S" (funcall f i j)))
    (terpri))
 5 6
 8 9