
- 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 - Adjustable Vectors
Adjustable Vector is a dynamic array which can change its size during runtime. It is useful feature which allows to work with a collection whose size is not known.
Key Concepts and Functions
Following are the key considerations to understand adjustable vector.
Adjustablity
We can increase/decrease size of an vector as required. This is an important feature where size of an vector 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 vector. It is a logical flag and can quicky reduce the size requirement of an vector 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 Vector
(make-array <array-size> :adjustable t :fill-pointer t :initial-element <initial-value>)
Where −
make-array − function to create array or vector.
array-size − initial size of an array or vector which can be changed later.
adjustable − flag to mark array or vector as adjustable.
fill-pointer − a fill pointer.
initial-element − to specify initial values to the array or vector elements.
initial-value − initial value of an array or vector element.
Example - Create Adjustable Vector
Create an adjustable vector with initial size of 5, a fill pointer as 0 and all elements are initialized to 0.
main.lisp
; define an adjustable vector (defvar my-vector(make-array 5 :adjustable t :fill-pointer 0 :initial-element 0)) ; print the Vector (print my-vector) (terpri) ; get and print the fill-Pointer (print (fill-pointer my-vector))
Output
When you execute the code, it returns the following result −
#() 0
Example - Adding element to Adjustable Vector
vector-push can be used to add element to end of the adjustable vector. It increments the fill-pointer automatically.
main.lisp
; define an adjustable vector (defvar my-vector(make-array 5 :adjustable t :fill-pointer 0 :initial-element 0)) ; add elements to the vector (vector-push 1 my-vector) (vector-push 2 my-vector) (vector-push 3 my-vector) ; Output: #(1 2 3) (print my-vector) (terpri) ; prints 3 (print (fill-pointer my-vector))
Output
When you execute the code, it returns the following result −
#(1 2 3) 3
Example - Removing element from Adjustable Vector
vector-pop can be used to remove element from the end of the adjustable vector. It decrements the fill-pointer automatically.
main.lisp
; define an adjustable vector (defvar my-vector(make-array 5 :adjustable t :fill-pointer 0 :initial-element 0)) ; add elements to the vector (vector-push 1 my-vector) (vector-push 2 my-vector) (vector-push 3 my-vector) ; Output: #(1 2 3) (print my-vector) ; remove last element (vector-pop my-vector) (terpri) ; Output: #(1 2) (print my-vector) (terpri) ; prints 2 (print (fill-pointer my-vector))
Output
When you execute the code, it returns the following result −
#(1 2 3) #(1 2) 2
Example - Extending Vector
vector-push-extend can be used to extend an adjustable vector. vector-push-extend adds an elements to the vector and increment the size of the vector.
main.lisp
; define an adjustable vector (defvar my-vector(make-array 3 :adjustable t :fill-pointer 0 :initial-element 0)) ; add elements to the vector (vector-push 1 my-vector) (vector-push 2 my-vector) (vector-push 3 my-vector) ; Output: #(1 2 3) (print my-vector) ; add 10 items to my-vector (dotimes (i 10) (vector-push-extend i my-vector)) (terpri) ; the vector now holds 13 elements, starting with 1,2,3 and then from 0 to 9. (print my-vector) (terpri) ; print the fill pointer (print (fill-pointer my-vector))
Output
When you execute the code, it returns the following result −
#(1 2 3) #(1 2 3 0 1 2 3 4 5 6 7 8 9) 13