
- LISP Tutorial
- LISP - Home
- LISP - Overview
- LISP - Environment
- LISP - REPL
- LISP - Program Structure
- LISP - Basic Syntax
- LISP - Data Types
- Lisp Macros
- LISP - Macros
- LISP - Backquote and Comma
- LISP - Code Generation Using Macro
- LISP - Variable Capture and Hygienic macro
- LISP - Scope and Binding
- LISP - Macro Writing Style
- LISP - Macro Characters
- LISP - Read-Time Macros
- LISP - Compiler Macros
- LISP - Uses of Macros
- Lisp Functions
- LISP - Functions
- LISP - Functions vs Macros
- LISP - Calling Function using funcall
- LISP - Calling Function using apply
- LISP - Closures
- LISP - Functions as Arguments
- LISP - Functions as Return Values
- LISP - Recursion
- LISP - Built-in Functions
- Lisp Predicates
- LISP - Predicates
- LISP - Generic Data Type Predicates
- LISP - Specific Data Type Predicates
- LISP - Equality Predicates
- LISP - Numeric Predicates
- LISP - Comparison Predicates
- LISP - Logical Predicates
- LISP - List Predicates
- LISP - Custom Predicates
- LISP - Chaining Predicates
- Lisp Arrays
- LISP - Arrays
- LISP - Adjustable Arrays
- LISP - Fill Pointers in Arrays
- LISP - Specialized Arrays
- LISP - Arrays Properties
- LISP - Iterating over Arrays
- LISP - Multidimensional Arrays
- LISP - Row-Major Order
- Lisp Strings
- LISP - Strings
- LISP - String Concatenation
- LISP - String Comparison
- LISP - String Case Conversion
- LISP - String Trimmimg
- LISP - String Searching
- LISP - Getting Substring
- LISP - String Replacement
- LISP - Sorting Strings
- LISP - Merging Strings
- LISP - Accessing Characters of String
- LISP - String length
- LISP - Escape Sequences
- Lisp Sequences
- LISP - Sequences
- LISP - Accessing Element of Sequence
- LISP - Sequence length
- LISP - Getting Subsequence
- LISP - Search Element in Sequence
- LISP - Sequence Concatenation
- LISP - Reversing a Sequence
- LISP - Mapping Sequence Element
- LISP - position of Element
- LISP - Remove an Element
- LISP - Sort Sequence
- LISP - Merge Sequences
- LISP - every function
- LISP - some function
- LISP - notany function
- LISP - notevery function
- Lisp Lists
- LISP - Lists
- LISP - Accessing Elements of Lists
- LISP - Modifications to Lists
- LISP - Using mapcar on List
- LISP - Using mapc on List
- LISP - Using reduce on List
- LISP - Removing elements from List
- LISP - Reversing a List
- LISP - Sorting a List
- LISP - Searching a List
- LISP - List vs Vectors
- LISP - Matrix Multiplication
- Lisp Vectors
- LISP - Vectors
- LISP - Creating Vectors
- LISP - Accessing Elements of Vectors
- LISP - Modifications to Vectors
- LISP - Adjustable Vectors
- LISP - Specialized Vectors
- LISP - Vector Functions
- Lisp Set
- LISP - Set
- LISP - Adding elements to the Set
- LISP - Getting SubSet from a Set
- LISP - Set Difference
- LISP - Set Exclusive OR
- LISP - Set Intersection
- LISP - Set Union
- LISP - Representing Set with HashTable
- LISP - List as Set vs HashTable as Set
- Lisp Tree
- LISP - Tree
- LISP - Recursive Traversal
- LISP - Inorder Traversal
- LISP - Preorder Traversal
- LISP - Postorder Traversal
- LISP - Depth First Traversal
- LISP - Modifying Tree
- LISP - Search Tree
- LISP - Binary Tree
- Lisp Hash Table
- LISP - Hash Table
- Adding Values to Hash Table
- Removing Values from Hash Table
- Updating Values of Hash Table
- Iterating Hash Table Entries
- Searching key in HashTable
- Checking Size of HashTable
- Using Custom Equality Check
- Lisp - Input − Output
- LISP - Input − Output
- LISP - Streams
- LISP - Reading Data from Streams
- LISP - Writing Data to Streams
- LISP - File I/O
- LISP - String I/O
- LISP - Formatting with Format
- LISP - Interactive I/O
- LISP - Error Handling
- LISP - Binary I/O
- Lisp - Structures
- LISP - Structures
- LISP - Accessors and Mutators
- LISP - Structure Options
- LISP - Structure Types
- LISP - Applications and Best Practices
- Lisp - CLOS
- LISP - CLOS
- Lisp - Objects
- LISP - Class
- LISP - Slots and Accessors
- LISP - Generic Functions
- LISP - Class Precedence
- LISP - Metaobject Protocol
- LISP - Multimethods
- LISP - Multiple Inheritance
- LISP - Method Combinations
- LISP - Method Combinations
- LISP - :before Method Combination
- LISP - :primary Method Combination
- LISP - :after Method Combination
- LISP - :around Method Combination
- LISP - + Method Combination
- LISP - and Method Combination
- LISP - append Method Combination
- LISP Useful Resources
- Lisp - Quick Guide
- Lisp - Useful Resources
- Lisp - Discussion
Lisp - Vectors
Vectors are one-dimensional arrays, therefore a subtype of array. Vectors and lists are collectively called sequences. Therefore all sequence generic functions and array functions we have discussed so far, work on vectors.
Creating Vectors
The vector function allows you to make fixed-size vectors with specific values. It takes any number of arguments and returns a vector containing those arguments.
Example
Create a new source code file named main.lisp and type the following code in it.
main.lisp
; create and assign a vector to v1 (setf v1 (vector 1 2 3 4 5)) ; create and assign a vector to v2 (setf v2 #(a b c d e)) ; create and assign a vector to v3 (setf v3 (vector 'p 'q 'r 's 't)) ; print v1 (write v1) ; terminate printing (terpri) ; print v2 (write v2) ; terminate printing (terpri) ; print v3 (write v3)
Output
When you execute the code, it returns the following result −
#(1 2 3 4 5) #(A B C D E) #(P Q R S T)
Please note that LISP uses the #(...) syntax as the literal notation for vectors. You can use this #(... ) syntax to create and include literal vectors in your code.
However, these are literal vectors, so modifying them is not defined in LISP. Therefore, for programming, you should always use the vector function, or the more general function make-array to create vectors you plan to modify.
The make-array function is the more generic way to create a vector. You can access the vector elements using the aref function.
Example
Update the source code file named main.lisp and type the following code in it.
main.lisp
; create and assign an array of size 5 initilized with 0 values (setq a (make-array 5 :initial-element 0)) ; create and assign an array of size 5 initilized with 2 values (setq b (make-array 5 :initial-element 2)) ; loop for 5 times (dotimes (i 5) ; set an array values (setf (aref a i) i)) ; print a (write a) ;terminate printing (terpri) ; print b (write b) ; terminate printing (terpri)
Output
When you execute the code, it returns the following result −
#(0 1 2 3 4) #(2 2 2 2 2)
Fill Pointer
The make-array function allows you to create a resizable vector.
The fill-pointer argument of the function keeps track of the number of elements actually stored in the vector. It's the index of the next position to be filled when you add an element to the vector.
The vector-push function allows you to add an element to the end of a resizable vector. It increases the fill-pointer by 1.
The vector-pop function returns the most recently pushed item and decrements the fill pointer by 1.
Example
Update the source code file named main.lisp and type the following code in it.
main.lisp
; create and assign an array of size 5 initilized with 0 values (setq a (make-array 5 :fill-pointer 0)) ; print a (write a) ; add a to the vector a (vector-push 'a a) ; add b to the vector a (vector-push 'b a) ; add c to the vector a (vector-push 'c a) ; terminate printing (terpri) ; print vector a (write a) ; terminate printing (terpri) ; add d to the vector a (vector-push 'd a) ; add e to the vector a (vector-push 'e a) ;this will not be entered as the vector limit is 5 (vector-push 'f a) ; print vector a (write a) ; terminate printing (terpri) ; remove last pushed element (vector-pop a) ; remove last pushed element (vector-pop a) ; remove last pushed element (vector-pop a) ; print vector (write a)
Output
When you execute the code, it returns the following result −
#() #(A B C) #(A B C D E) #(A B)
Vectors being sequences, all sequence functions are applicable for vectors. Please consult the sequences chapter, for vector functions.