Scala has a lot to like so far, although at first I found it quite daunting. I remember feeling that I was ready to get started with Python after doing the Python tutorial, but with Scala, it's clear that I have yet to learn about many of the features of the language.

For my first steps, I decided to make a simple dense matrix class, based on Scala

`List`

s, which the textbook describes as "the workhorses of Scala". Initially, I wanted to make the matrix generic, but discovered that I would need some special voodoo to ensure that the type parametrization of the matrix would only occur for classes that had the appropriate operators (`+`

, `-`

, `*`

and so on). That is way beyond me at this stage, so I went for a concrete implementation using `Double`

sHere is a blow-by-blow account of the class:

The

`Matrix`

class takes a `List`

of its rows as a parameter, and the rows are then stored in a `val`

named `elements`

.Here, the number of rows and columns of the matrix are calculated from the list of elements, and we have a

`require`

directive which checks that all rows of the matrix have the same number of elements (ie. the same number of columns). The `forall`

method returns `true`

if a particular predicate is true for all members of a `List`

. In this case, our predicate is constructed as the function `_.length == nCols`

which is equivalent to the function object `(x: List[Double]) => x.length == nCols`

.These methods define addition and subtraction by adding rows of the matrices, while we get

`transpose`

for free from `List`

. Again in these methods, the underscore notations are equivalent to function objects. For example, `_+_`

is in this case equivalent to `(x: Double, y: Double) => x + y`

This is a really fun way to multiply matrices. It directly implements the concept of multiplying rows of one matrix by the columns of the other. The inner

`yield`

produces a `List[Double]`

formed from the dot products of each row of the left matrix by all of the columns of the right matrix. This produces a single row of the result matrix. The outer `yield`

simply collects all of the rows of the result matrix.For pretty-printing, this adds the

`toString`

method.This object adds the ability to construct a

`Matrix`

from an array of `Double`

s provided to the `apply`

method.If the above code is in a file called

`Matrix.scala`

, then we can do the following in the Scala interpreter:So, dense matrices with multiplication, addition, subtraction and transposition can be implemented fairly easily in Scala. The next steps could include making the

`Matrix`

class parametrizable (so we could have a `Matrix[Int]`

or `Matrix[Double]`

). It would also be interesting to investigate the performance of `Array`

-based vs `List`

-based matrix operations. I think array-based implementations would definitely win out in the case of operations that need frequent random element access (like Gaussian elimination), but may be no better than using lists for things like multiplication and addition.