
- 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 - Matrix Multiplication
Matrix Multiplication
Matrix multiplication is one of the fundamental operation in linear algebra. It is practically used in many fields like computer graphics, physics and machine learning. Following are the key points to be noted before understanding a matrix multiplication.
Dimensions− Two matrices, A and B can be multiplied only if columns of matrix A are same as rows in matrix B.
Resulted Matrix Dimensions− Consider a matrix A of dimension m x n and a matrix B of dimension n x p, the result of multiplication of A and B matrices, C will be of m x p.
Process of Multiplication− Each element of Resulted Matrix C[i][j] is calculated as product of ith row of matrix A with jth column of matrix B.
Example of Matrix Multiplication
Let's have Matrix A of 2 x 3 as shown below
Matrix A
[ [1, 2, 3], [4, 5, 6] ]
Let's have Matrix B of 3 x 2 as shown below
Matrix B
[ [7, 8], [9, 10], [11, 12] ]
Result of Matrix Multiplication will be computed using following way −
C[0][0] = A[0][0] * B[0][0] + A[0][1] * B[1][0] + A[0][2] + B[2][0] = (1 * 7) + (2 * 9) + (3 * 11) = 7 + 18 + 33 = 58
Resulted Matrix C
[ [58, 64], [139, 154] ]
Let's write a LISP Funtion to implement matrix manipulation.
main.lisp
(defun multiply-matrix (matrixA matrixB)( ; initialize rows and columns of matrices let( (rowsA (length matrixA)) (colsA (length (first matrixA))) (rowsB (length matrixB)) (colsB (length (first matrixB))) ) ; if columns of A is not same as rows of B (if (/= colsA rowsB) (error "Incompatible Dimensions for matrix multiplication.") (loop for i from 0 below rowsA collect ( loop for j from 0 below colsB collect ( loop for k from 0 below colsA sum (* (elt (elt matrixA i) k) (elt (elt matrixB k) j)))))))) ;; Multiply two matrices (let ((matrixA '((1 2 3) (4 5 6))) (matrixB '((7 8) (9 10) (11 12)))) (let ((result (multiply-matrix matrixA matrixB))) (loop for row in result do (format t "~a~%" row))))
Output
When you execute the code, it returns the following result −
(58 64) (139 154)
Explanation
defun matrix-multiply − Define a function matrix-multiply
let − Dimensions of matrices are stored in local variables. first returns the first row. We're assuming here that each row have same number of element.
Dimension Check − If columns of matrix A is not same as rows as matrix B then error is thrown.
-
Nested Loop − We're using loop construct for iteration.
Outer loop iterates over rows of matrix A using i.
middle loop iterates over columns of matrix B using j.
inner loop iterates over columns of matrix A using k.
elt − elt is used to access element of the list. elt (elt matrixA i) k refers to A[i][k].
sum − using sum function, we're computing each element of resultant matrix.
collect − using collect, we're building the result. Innermost collect creates the rows of resulted matrix and middle collect builds the complete matrix