This time around, I’ve decided to toss the translations for Ruby, Factor, and Erlang into the same post instead of trying to juggle multiple posts and point them all at one another. So, without further ado …

## Section 1.1.6

Let’s take a look at section 1.1.6, the goal of this section is to look at conditional expressions through implementing an absolute value procedure. the book iterates through a couple of versions, trimming away fat. In each of my examples below, I’ve only shown the final product.

In Ruby, the code should look something like this:

def abs(num)

if num < 0

num = -num

end

return num

end

In Factor it looks like this:

: abs ( n -- n ) dup 0 < [ -1 * ] [ ] if ;

And in Erlang it looks like this (I’ve left out the administrative bits from the top of the file):

abs(A) ->

case ( A < 0) of

true -> -1 * A;

false -> A

end.

## Exercise 1.3

Esercise 1.3 asks the reader to write a procedure that takes three numbers and returns the sum of the squares of the largest two of them. In each case below, I rely on the previously defined square and sum-of-squares (sum_of_squares) procedures.

Ruby was pretty easy:

def sum_squares_of_larger(a, b, c)

sorted_nums = [a, b, c].sort.reverse

sum_of_squares(sorted_nums[0], sorted_nums[1])

end

Factor took me a while to figure out (mostly in trying to figure out how to build the array):

: top-two ( x,y,z -- x,y ) 3array natural-sort reverse first2 ;

: sum-squares-of-larger ( x,y,z -- x ) top-two sum-of-squares ;

I’m least sure of my Erlang code. I couldn’t find a good function for sorting the array, so I borrowed the qsort function from Programming Erlang. In any case, here’s my cut at it:

qsort([]) ->

[];

qsort([Pivot|T]) ->

qsort([X || X <- T, X < Pivot])

++ [Pivot] ++

qsort([X || X <- T, X >= Pivot]).

last_two([H|T]) ->

T.

sum_of_squares_of_list(L) ->

lists:sum([square(A) || A <- L]).

sum_squares_of_larger(A, B, C) ->

sum_of_squares_of_list(last_two(qsort([A,B,C]))).

## What I learned

The biggest thing I’ve taken away from this exercise so far is that I really need a good Factor book that covers both the language and the vocabulary. Along similar lines, Programming Erlang is a good book, but it could have spent some more time on basic programming (especially covering the provided functions in something other than an appendix).

Factor has been the language that’s been hardest to wrap my mind around so far. At the same time, it’s the one that I’ve enjoyed the most—I also think the word definitions have a sort of terse beauty. I think Ruby is probably the one that most programmers could just pick up and maintain though.

Next up, Section 1.1.7 “Square Roots By Newton’s Method”.

## 6 comments:

Something must be in the air. I started going through SICP this weekend. From what I've gathered thus far, solving the problems using all the tricks in your bag will hind the insight that SICP provides. For example, the sum_squares_of_larger can't use list because they haven't been introduced yet. At that point in the book, all you have are combinations. That is a very different, and much more fun, problem to solve. Just something to consider if you are taking the time to go through SICP.

For a sorting function, what's wrong with lists:sort(L)?

A more generic version of last_two(L) would be:

last_two(L) ->

[B,A|_] = lists:reverse(L),

[A,B].

BR,

Ulf W

Ulf,

noting wrong with lists:sort(L) at all. I just hadn't found it yet.

def abs(num)

num < 0 ? -num : num

end

def sum_squares_of_larger(*nums)

nums.sort[-2..-1].inject{|a,b|a*a+b*b}

end

In factor you would do this

: sum-squares-of-larger max max sum-of-squares ;

Post a Comment