Lisp - Specialized Vectors

---

---

A specialized vector refers to a vector which holds only a specific type of an element. In Lisp, an array or vector can hold any kind of object. A specialized array is way to restrict this functionality where only a specific type of element can be added. Following are key advantage of creating a specialized vector.

• Type Restriction− We can store specific type elements like integers, chars and single-float numbers which allows LISP to optimize storage of vectors of these primary types.

• Increased Efficiency− LISP can use more efficient storage mechanism and avoid overhead of type checks during every element access.

• Optimized Memory Allocation− Specialized vectors are generally for primitive types thus requiring less storage than general type vectors.

• Compiler Optimization− Compiler can generate more efficient machine code when type of element is known in advance.

Commonly Specialized Array Types

We can use element-type construct with make-array function to define the required type of elements as shown below:

Vector of Bits

We can create a vector of bits to efficiently store boolean data.

; Create a vector of bits
(defvar bit-vector (make-array 10 :element-type 'bit))
; print vector
(print bit-vector)
; print 0
(print (aref bit-vector 2))        
; set a value
(setf (aref bit-vector 2) 1)
(terpri)
; print 1
(print (aref bit-vector 2))

Output

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

#*0000000000
0
1

Vector of Bits and characters

We can create specialized vectors as literal as shown below:

; Create a vector of bits
(defvar bit-vector #*010101)
; print vector
(print bit-vector)
(terpri)
; print 1
(print (aref bit-vector 3))        

; Create a vector of characters using string literal
(defvar char-vector "Hello")
(terpri)
; print vector
(print char-vector)
(terpri)
; print l
(print (aref char-vector 3)) 

Output

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

#*010101 
1 
"Hello" 
#\l

Vector of Integers

We can create a vector of integers to store numerical data.

; Create a vector of integers
(make-array 10 :element-type 'integer)        

Vector of Strings

We can create a vector of strings to store character sequences.

; Create a vector of strings
(make-array 10 :element-type 'character)        

Vector of Single-Float

We can create a vector of single precision floating point numbers for numerical computations.

; Create a vector of single-float
(make-array 10 :element-type 'single-float)        

Advantages of Specialized Vectors

• Type Safety− Due to element type restriction, type safety is ensured by LISP system automatically.

• Increased Performance− Specialized array access/modification is significantly faster than general arrays.

• Efficient Memory Usage− Lesser memory requirement as no storage requirement for type of each element.

Example

Following code check and predicates on different values.

main.lisp

; define a vector of integers
(defvar my-vector (make-array 10 :element-type 'integer))

; assign integer values
(setf (aref my-vector 0) 10)
(setf (aref my-vector 1) 20)
(setf (aref my-vector 2) 30)

; Output: #(10 20 30 NIL NIL NIL NIL NIL NIL NIL)
(print my-vector)  

Output

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

#(10 20 30 NIL NIL NIL NIL NIL NIL NIL)