Okay, this code isn't the cleanest, and to those of you who don't know Goo, you will scratch your heads anyway. BUT, in spite of that, I am pasting the 84 lines of methods ANYWAY, so feast your eyes.
coderforums.goo
; Our master class
(dc <matrix> (<any>))
; Its only real member
(dp rows (<matrix> => <vec>))
; Define a "fab" that will make a matrix
(dm matrix (nrows|<int> ncols|<int> => <matrix>)
(def M (new <matrix>))
(set (rows M) (fab <vec> nrows))
(rep loop ((i 0))
(when (< i nrows)
(set (elt (rows M) i) (fab <vec> ncols))
(loop (+ i 1))))
M)
; To be used for the multiplication method
(dm numrows (M|<matrix> => <int>)
(len (rows M)))
; This method naively assumes that all rows in the
; matrix are the same length, but as long as it was
; created with the above matrix method, it should
; be the case that they are all the same length.
(dm numcols (M|<matrix> => <int>)
(len (1st (rows M))))
; Get item at (row, col), handy in general, and handy
; in some of the other methods.
(dm get-item (M|<matrix> row|<int> col|<int> => <int>)
(elt (elt (rows M) row) col))
; Just to make things a little cleaner looking:
(dm get-row (M|<matrix> index|<int> => <vec>)
(elt (rows M) index))
; Really handy for the multiplication method
(dm get-col (M|<matrix> index|<int> => <vec>)
(def retcol (fab <vec> (numrows M)))
(rep loop ((i 0))
(when (< i (numrows M))
(set (elt retcol i) (get-item M i index))
(loop (+ i 1))))
retcol)
; I needed a zip function to do some nice pairing
; between two vectors, so I made my own. This is used
; in the dot-product function.
(dm my-zip (v1|<vec> v2|<vec> => <vec>)
(when (= (len v1) (len v2))
(def retvec (fab <vec> (len v1)))
(rep loop ((i 0))
(when (< i (len v1))
; This could probably be done more cleanly, but hey it works
(set (elt retvec i) (rev (add (fabs <vec> (elt v1 i)) (elt v2 i))))
(loop (+ i 1))))
retvec))
; Lame as this is, I'm using it because it makes things
; easy and because I'm too lazy to figure out the more
; goo-ish way of doing this.
(dm multpair (foo|<vec> => <int>)
(* (elt foo 0) (elt foo 1)))
; Really cool (to me anyway) that this works.
(dm dot-product (v1|<vec> v2|<vec> => <int>)
(fold+ + (map multpair (my-zip v1 v2))))
; The method we've all been waiting for!
(dm mult (M1|<matrix> M2|<matrix> => <matrix>)
(when (= (numcols M1) (numrows M2))
(def M (matrix (numrows M1) (numcols M2)))
(rep row-loop ((row 0))
(when (< row (numrows M))
(rep col-loop ((col 0))
; We actually iterate over the rows and columns of the
; result matrix and set those by taking the dot product
; of the
(when (< col (numcols M))
(set (elt (elt (rows M) row) col)
(dot-product (get-row M1 row) (get-col M2 col)))
(col-loop (+ col 1))))
(row-loop (+ row 1))))
M))
(edit: oops, didn't finish that last comment, add on "row from the left matrix and column of the right matrix", it's empty in the attachment too)
Now, from someone whose primary languages are Python and C/C++ ... that's a bit of a deviation. So use this as inspiration to try even those "weird" languages :)
Anyway, what would the code be without testing? Here's a bit of sample code from the bottom of that file:
; Now for some example code:
;
; Test case 1 - 2x2 identity squared
;
; /1 0\ /1 0\ - /1 0\
; \0 1/ \0 1/ - \0 1/
;
; Test case 2 - 2x3 times 3x2
;
; /1 2 3\ /1 2\ /22 28\
; \4 5 6/ |3 4| = \49 64/
; \5 6/
;
; Test case 1
(dv mat1a (matrix 2 2))
(dv mat1b (matrix 2 2))
(set (rows mat1a) (fabs <vec> (fabs <vec> 1 0) (fabs <vec> 0 1)))
(set (rows mat1b) (fabs <vec> (fabs <vec> 1 0) (fabs <vec> 0 1)))
(mult mat1a mat1b)
; Test case 2
(dv mat2a (matrix 2 3))
(dv mat2b (matrix 3 2))
(set (rows mat2a)
(fabs <vec> (fabs <vec> 1 2 3) (fabs <vec> 4 5 6)))
(set (rows mat2b)
(fabs <vec> (fabs <vec> 1 2) (fabs <vec> 3 4) (fabs <vec> 5 6)))
(mult mat2a mat2b)
Complete with ASCII art!
Here's the pertinent output from running goo < coderforums.goo (attached below as coderforums.txt):
goo/user 0<= goo/user 0=> #[#[1 0] #[0 1]]
goo/user 0<= goo/user 0=> #[#[1 0] #[0 1]]
goo/user 0<= goo/user 0=> #{<matrix> rows: #[#[1 0] #[0 1]]}
goo/user 0<= goo/user 0=> #[#[1 2 3] #[4 5 6]]
goo/user 0<= goo/user 0=> #[#[1 2] #[3 4] #[5 6]]
goo/user 0<= goo/user 0=> #{<matrix> rows: #[#[22 28] #[49 64]]}
The first two lines of each triple are just restating the matrix that has just been set. The third line in each triple is the result of the mult command.
Well, before I make the "longest single post" record totally unbreakable by adding more to this post, I'm going to stop here and attach the code.
(edit: I lied, I forgot I need to give vomjom mad props for his help in getting me over some of the initial bumps and for basically writing that "matrix" method at the top for me, and jemfinch for reminding me how handy the zip function is for getting cross products)