As a quick Scala example, I just needed to write a “sum of the squares” algorithm for a “Pearson Correlation” function I’m working on, and initially wrote it like this using
val sumOfTheSquares = movieRatingsMap.values.map(rating => Math.pow(rating, 2)).sum
If you know Scala, and know that
movieRatingsMap is a
Map of movies and my ratings of those movies, I think that line of code is fairly easy to read. That line can also be written like this:
val sumOfTheSquares = movieRatingsMap.values.map(Math.pow(_, 2)).sum
though even after using Scala for several years, I still find that line to be a little less readable.
Using ‘foldLeft’ instead
As I thought about this a little more, I realized that this could be a good place to use a reduce or fold algorithm. You can’t really use the
reduce family of methods for this algorithm, but you can use
foldLeft, and that code looks like this:
val sumOfTheSquares = movieRatingsMap.values.foldLeft(0.0)(_ + Math.pow(_, 2))
Personally I think that line of code is harder to read, but it may be more efficient than the map/sum approach, because the map/sum solution requires an intermediate collection, while
foldLeft presumably just creates a simple sum of the squares as it walks through each value in the
As an interesting quiz, do you know why you can’t use
reducewith this algorithm?
In summary, this code shows a few different ways to create a “sum of the squares” algorithm in Scala. I’m sure there are many more ways to do this, but these are the first two approaches that came to mind.
Which reminds me of a Viktor Klang proverb: “If you only have one solution, it may well be the worst.”