Lisp - Adjustable Arrays

---

---

In Lisp, when we define a array, it is of fixed size and cannot be altered. But using adjustable flag while defining an array we can mark it adjustable. This is a powerful option which allows us to change size of an array dynamically.

Key Concepts

Following are the key considerations to understand adjustable array.

Adjustablity

We can increase/decrease size of an array as required. This is an important feature where size of an array is not known at time of creation and can vary as program processes.

Fill Pointer

Fill Pointer is a special index marking the end of the array. It is a logical flag and can quicky reduce the size requirement of an array without making change to underlying physical storage. Fill pointer helps in identifying the total number of elements in use.

Allocation

Whenever we need to adjust an array size to a bigger block of memory, Lisp returns the new array while copying existing elements. It is generally an expensive operation and it is important for performance point of view.

Syntax - Creating Adjustable Array

(make-array <array-size> :adjustable t :fill-pointer t :initial-element <initial-value>)

Where −

• make-array − function to create array.

• array-size − initial size of an array which can be changed later.

• adjustable − flag to mark array as adjustable.

• fill-pointer − a fill pointer.

• initial-element − to specify initial values to the array elements.

• initial-value − initial value of an array element.

Example - Create Adjustable Array

(make-array 10 :adjustable t :fill-pointer t :initial-element 0)

Here, we've created an adjustable array of size 10 with each element initialized with 0.

Syntax - Increase Array Size

; Increase size to 20
(setf my-array (adjust-array my-array 20)) 

Where −

• (adjust-array my-array 20) − function to adjust size of my-array array to new size.

• setf my-array − assign the returned array with updated size to my-array object

Syntax - Decrese Array Size

; decrease size to 5 (logical size)
(setf my-array (adjust-array my-array 5 :fill-pointer t)) 

Where −

• fill-pointer − flag to modify the logical size

Use of fill-pointer

Following are important LISP functions to be used in conjuction with fill-pointer.

• array-total-size − returns the array size, the number of elements an array can hold.

• fill-pointer − returns the current position of fill pointer.

• (setf (fill-pointer <array-name>) <value>) − sets the fill pointer of array to a new value.

Example - Increasing Array Size dynamically

Following example shows a case of array size growth. Here we've created an array of 5 elements initially. During iteration, when fill-pointer crosses array size, array size is doubled.

main.lisp

; define an adjustable array of size 5
(defvar my-dynamic-array (make-array 5 :adjustable t :fill-pointer t))

; print the original array
(print my-dynamic-array)

; Loop for 16 elements
(loop for i from 0 to 15 do
   ; if fill-pointer is same as array size
   (when (= (fill-pointer my-dynamic-array) (array-total-size my-dynamic-array))
      ; double the array size
      (setf my-dynamic-array (adjust-array my-dynamic-array (* (array-total-size my-dynamic-array) 2))))
  ; add the element to the array	  
  (setf (aref my-dynamic-array i) i)
  ; Increment fill pointer
  (incf (fill-pointer my-dynamic-array))) 

; print the updated array
(print my-dynamic-array)

Output

When you execute the code, it returns the following result −

#(NIL NIL NIL NIL NIL)
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 NIL NIL NIL NIL NIL)

When to use Adjustable Array

Adjustable array is a powerful data structure. Understanding use of fill-pointer is very important in efficiently using memory allocations. We can use adjustable arrays in following cases.

• When size of the data is not known in advance.

• When we need to add/remove elements from the collection dynamically.

• When space is limited and we've to focus to efficient memory allocation.