While learning Linear Algebra and calculating a bunch of vector operations by hand I was getting a bit tired, that’s when I thought about making my life easier with a bit of Common Lisp code.
For this little experiment I’m going to represent vectors using regular lists.
The simplest operation I can think of is scalar multiplication, where you multiply all components in a vector by a scalar value, that is, just a real number.
(defun v@ (u alpha)
"Returns scalar multiplication of U by ALPHA."
(map 'list #'(lambda (x)
(* x alpha))
u))
map expects a return type (here we’re returning a list), a function that will run on each element of the list (here we’re using simple lambda that multiplies x by alpha), and the sequence we want to apply our function to, which is u.
Calling v@ gives us the expected answer:
* (v@ '(1 2 3) 5)
(5 10 15)
Next we will implement adding, subtracting, and multiplying vectors.
The v+ function is pretty similar to the v@ function we defined earlier:
(defun v+ (u v)
"Returns the addition of the vectors U and V."
(mapcar #'(lambda (x y)
(+ x y))
u
v))
mapcar expects a function that will run on each pair, with the first value being the nth component in a vector U, and second value being the nth component in a vector V.
Calling v+ should give you the following output:
* (v+ '(1 2 3) '(4 5 6))
(5 7 9)
The functions for substraction and multiplication are pretty much the same.
(defun v- (u v)
"Returns the subtraction of the vectors U and V."
(mapcar #'(lambda (x y)
(- x y))
u
v))
(defun v* (u v)
"Returns the multiplication of the vectors U and V."
(mapcar #'(lambda (x y)
(* x y))
u
v))
The dot product of two vectors is calculated by multiplying the nth component in a vector U with the nth component in a vector V, and returning the sum of those products.
(defun v. (u v)
"Returns the dot product between the vectors U and V."
(apply #'+
(mapcar #'(lambda (x y)
(* x y))
u
v)))
The only difference between v. and the previous functions is the use of apply. apply applies some function, in this case +, to all items in the list.
It’s like running:
(+ 1 2 3)
But using the elements from the list mapcar returns.
Calling v. should give you the following output:
* (v. '(1 2 3) '(4 5 6))
32
To get the modulus, or magnitude of a vector we get the square root of the sum of all components squared.
(defun v-modulus (u)
"Returns the modulus, or magnitude of the vector U."
(sqrt (apply #'+
(map 'list #'(lambda (n)
(expt n 2))
u))))
Here we see the use of the expt function, it expects a base and a exponent.
Calling v-modulus should give you the following output:
* (v-modulus '(1 2))
2.236068
Getting the angle between two vectors is a bit more complex.
We need to get the arccosine of the dot product of U and V over the product of the modulus of U and V. A bit long-winded isn’t it, I find the code a bit easier to read.
(defun v0 (u v)
"Returns the angle between the vectors U and V."
(acos (/ (v. u v)
(*
(v-modulus u)
(v-modulus v)))))
The code is almost a translation of the explanation above, luckily for us, Common Lisp provides an arccosine function called acos.
Calling v0 should give you the following output:
* (v0 '(1 0) '(0 3))
1.5707964
And that’s probably not what you expected, right? That’s because it’s returning the angle in radians, so all that’s left to do is create a function to convert radians to degrees.
(defun radians-to-degress (radians)
"Converts RADIANS to degrees."
(nth-value 0 (round (* radians (/ 180 PI)))))
We can do the conversion by multiplying the angle in radians by 180 over PI.
The round function rounds the resulting value, round returns multiple values, the rounded number and the remainder.
Since we only care about the rounded number we can ignore the remainder, the nth-value function let’s do exactly that! Getting the zeroth return value from round.
Let’s modify v0 to make use of the radians-to-degrees function:
(defun v0 (u v)
"Returns the angle between the vectors U and V."
(radians-to-degress
(acos (/ (v. u v)
(*
(v-modulus u)
(v-modulus v))))))
Now v0 should give the answer in degrees, like we expected:
* (v0 '(1 0) '(0 3))
90
To me that was a pretty good exercise, making me understand both Linear Algebra and Common Lisp a bit better. I hope it was useful for you too!