The only wrong way

SICP Exercise 1.13

ellerain — Fri, 20 Aug 2010 18:22:00 +0000

A non-programming exercise. I have zero idea why it is here.
Anyhow.

SICP Exercise 1.13

fi = (1 + sqrt(5))/2
psi = (1 – sqrt(5))/2 
 
Show that (1) fib(n) = (fi^n – psi^n)/sqrt(5)
 
For n = 1 and n = 2 simple calculation will show that (1) holds. 
 
Then let’s prove: (2) (fi^(n-1) – psi^(n-1))/sqrt(5) + (fi^n – psi^n)/sqrt(5) = (fi^(n+1) – psi^(n+1))/sqrt(5)
 
(fi^(n-1) – psi^(n-1))/sqrt(5) + (fi^n – psi^n)/sqrt(5) = [regrouping and using commutation]
 
(fi^(n-1) * (1+fi) – psi^(n-1) (1+psi))/sqrt(5) = [since 1+fi = fi^2 and 1+psi = psi^2]
 
(fi^(n-1) * (fi^2) – psi^(n-1) (psi^2))/sqrt(5) = 
 
(fi^(n+1) – psi^(n+1))/sqrt(5)
 
QED.
 
Even after completing it I still have no idea what is this doing in SICP.

SICP Exercise 1.12

ellerain — Fri, 20 Aug 2010 17:22:47 +0000

And more of the same. For the fun, I coded calculations for both the rotated and normal placement of rows and columns. It’s really the typing and hand-stretching exercise.
Anyhow.

SICP Exercise 1.12

    1 #light
    2 namespace SICP
    3 open System
    4 
    5 module Ex1d12 =
    6     let rec pascal_triangle_element x y =
    7         if (x < 0) && (y < 0)
    8             then 0
    9         elif (x = 0) || (y = 0)
   10             then 1
   11             else
   12                 pascal_triangle_element (x-1) y + pascal_triangle_element x (y-1)
   13 
   14     let pascal_triangle row place =
   15         if (row < 0) || (place<0) || (place > row)
   16             then 0
   17             else
   18                 pascal_triangle_element (row-place) (place)
   19 
   20     let execute =
   21         pascal_triangle 2 1

This stuff is really addictive.

SICP Exercise 1.11

ellerain — Fri, 20 Aug 2010 16:51:24 +0000

This exercise is only fascinating if you try to nail it completely inside your head, without writing the transformations down on the piece of paper. It almost requires not-posting the solution to avoid spoiling the fun. On the other hand, I could’ve gotten it wrong.
Anyhow.

SICP Exercise 1.11

    1 #light
    2 namespace SICP
    3 open System
    4 module Ex1d11 =
    5     let rec triple_fib_iter_inner accumulator prev before_prev countdown =
    6         if countdown = 3
    7             then accumulator
    8             else triple_fib_iter_inner (accumulator+prev+before_prev) (accumulator) (prev) (countdown – 1)
    9 
   10     let triple_fib_iter n =
   11         if n<4  then n
   12                 else triple_fib_iter_inner 3 2 1 n
   13 
   14     let rec triple_fib_rec n =
   15         if n<4 then n
   16               else (triple_fib_rec (n-1) + triple_fib_rec (n-2) + triple_fib_rec (n-3))
   17 
   18     let execute =
   19         triple_fib_iter 7 – triple_fib_rec 7
 

I had a small problem here when I accidentally wrote (countdown -1) instead of (countdown - 1). That’s five minutes of my life I won’t get back.

Also, this is an example of a recurrence relation. It always is fascinating to quickly read about such things on Wikipedia; great stuff to talk to other people at parties about is to be discovered there. Did you know that linear recursive sequences are precisely the sequences whose generating function is a rational function?

SICP Exercise 1.10

ellerain — Fri, 20 Aug 2010 11:00:00 +0000

SICP seems to give some strange definition for the Ackermann function; otherwise it’s really calculus, not the Comp Sci stuff.
Anyhow:

SICP Exercise 1.10

    1 #light
    2 namespace SICP
    3 open System
    4 module Ex1d10 =
    5     let rec A x y =
    6         match y with
    7         |   0 -> 0
    8         |   1 -> 2
    9         |   _ -> if x = 0 then 2*y else A (x-1) (A x (y-1))
   10 
   11     let execute =
   12         printfn “A 1 10 = %d” (A 1 10)
   13         printfn “A 2 4 = %d” (A 2 4)
   14         printfn “A 3 3 = %d” (A 3 3)
   15         ignore Console.ReadKey

As for the second part:
A 0 n === 2*n
A 1 n === 2^n
A 2 n === 2^(2^(2^…(2^2))…) n times – it’s called Tetration

(- It has a name?
- Yes, little girl. Operations do traditionally have names in most cultures.)[1:40]

And some additional reading:

SICP Exercise 1.9

ellerain — Fri, 20 Aug 2010 10:54:13 +0000

Tail recursion and iterative versus recursive processing. The main idea behind tail recursion is to generate iterative process from recursive function by rewriting your code in a certain way. Although every recursive process can be converted into iterative (see Church–Turing thesis), tail-recursion can only be applied to a certain class of functions.
Anyhow.

SICP Exercise 1.9

A bit of complication here is caused by the fact that incr and decr in F# are in-place and are defined as int ref -> uint. Bugger. Attempting to use these means getting familiar (more like acquainted) with a concept of F# reference cells. Fortunately, there are only three things about those we need to know right now:

You use the ref operator before a value to create a new reference cell that encapsulates the value.
When you create a reference cell by using the ref operator, you create a copy of the underlying value as an encapsulated mutable value.
You can dereference a reference cell by using the ! (bang) operator.

I bolded out the important parts. Creating new reference variable every time we increment can’t be good for your soul, but this will have to do for the time being (Shoot me a comment if you know how to do it better.)

    1 #light
    2 namespace SICP
    3 open System
    4 module Ex1d9 =
    5     let inc a =
    6         let c = ref a
    7         incr c
    8         !c
    9 
   10     let dec b =
   11         let c = ref b
   12         decr c
   13         !c
   14 
   15     let rec (|+) a b =
   16         if a = 0 then b else inc ((|+) (dec a) b)
   17 
   18     let rec (@+) a b =
   19         if a = 0 then b else dec a @+ inc b
   20 
   21     let execute =
   22         let result_iter = 100000 @+ 1
   23         printfn “Iterative summation result: %d” result_iter
   24 
   25         let result_rec = 100000 |+ 1
   26         printfn “Recursive summation result: %d” result_iter
   27 
   28         ignore Console.ReadKey

Since I wanted to evaluate both recursive and iterative in the same module, I did name them differently, so in retrospective I could’ve used standard + operator in inc and dec functions. Oh well. Couple of notes here:

100000 is a random number which seems to work for me – iteration takes not that long to finish, while recursion overflows the stack.
Note how our operators while technically commutative when executed on ideal machine are not commutative in terms of time required (both) or the result on non-ideal machine (recursive).
@+ as an infix operator? I <3 it

SICP Exercise 1.8

ellerain — Thu, 19 Aug 2010 19:52:06 +0000

Is a bit of the same stuff as 1.7, polishing F# typing skills.

SICP Exercise 1.8

    1 #light
    2 namespace SICP
    3 open System
    4 module Ex1d8 = 
    5     let is_good_enough latest_guess last_guess x = 
    6         (abs (latest_guess – last_guess) < (0.0001 * last_guess))
    7 
    8     let improve_guess guess x = 
    9         (2.0*guess + x/(guess*guess))/3.0
   10 
   11     let rec inner_cubic_iter latest_guess last_guess x = 
   12         if is_good_enough latest_guess last_guess x
   13             then latest_guess
   14             else inner_cubic_iter (improve_guess latest_guess x) latest_guess x
   15 
   16     let cubic_root_iter first_guess x = 
   17         inner_cubic_iter first_guess (improve_guess first_guess x) x
   18 
   19 
   20     let execute = 
   21         let a = 0.000000001
   22 
   23         printfn "[New-Calculated] Cubic root of %e is %e" a (cubic_root_iter 0.5 a)
   24 
   25         let b = Double.MaxValue/2.0
   26         printfn "[New-Calculated] Cubic root of %e is %e" (b) (cubic_root_iter 2.0 b)
   27 
   28         ignore (Console.ReadKey())

SICP Exercise 1.7

ellerain — Thu, 19 Aug 2010 19:41:13 +0000

The distinction between mathematical function and programming procedure, in the form section 1.1.7 puts it reminds me of wave-particle duality.
There was another distinction between function and procedure – in Pascal procedures are functions which do not return a result.
I can’t use ‘?’ or ‘-’ as part of my function names (and it makes me sad) >.<

Anyhow.

SICP Exercise 1.7

    1 #light
    2 namespace SICP
    3 open System
    4 
    5 module Ex1d7 = 
    6 
    7     let is_good_enough_impr latest_guess last_guess = 
    8         abs (latest_guess – last_guess) < (0.0001 * latest_guess)
    9 
   10     let rec sqrt_iter_inner latest_guess last_guess x = 
   11         if is_good_enough_impr latest_guess last_guess
   12             then latest_guess
   13             else sqrt_iter_inner (Ex1d6.improve_guess latest_guess x) latest_guess x
   14 
   15 
   16     let sqrt_iter guess x = 
   17         if Ex1d6.is_good_enough guess x
   18             then guess 
   19             else sqrt_iter_inner (Ex1d6.improve_guess guess x) guess x 
   20 
   21     let execute = 
   22             let a = 0.0000000001
   23 
   24             printfn "[New-Calculated] Square root of %f is %f" a (sqrt_iter 0.5 a)
   25             printfn "[Old-Calculated] Square root of %f is %f" a (Ex1d6.sqrt_iter 0.5 a)
   26 
   27             let b = Double.MaxValue/2.0
   28             printfn "[New-Calculated] Square root of %e is %e" (b) (sqrt_iter 2.0 b)
   29             printfn "[Old-Calculated] Square root of %e is %e" (b) (Ex1d6.sqrt_iter 2.0 b)
   30 
   31             ignore (Console.ReadKey())

I used Ex1d6 code here to promote code reuse

So. It is fairly obvious why old version didn’t work for small numbers: if x is of the same order as our arbitrary precision s then x+-s is not a good approximation for x. In other words: absolute precision values are bad for arbitrary input in such a general function.

The problem with larger numbers is somewhat more tricky: it boils down to the representation of floating-point numbers in the computer memory. Floating-point number is represented as +-mantissa * 2^exponent and stored as (sign)(mantissa)(exponent), packed in some amount of bit (i.e. float 32 – 32 bit) [It's a bit more complicated but nevermind that]. So when you are trying to calculate a square root of the large number using 1.6 version of is_good_enough and improve_guess, there will come a moment when improve_guess is returning the same number (‘guess’) over and over again. When you square that number it’s not close enough to the target (‘x’), all because you are dropping small parts of guess’ mantissa on both multiplication and division. Those small parts, however, are being multiplied by 2^exponent (think ~2^153 for the ‘guess’ for the double precision), so the difference on the is_good_enough check is still greater than our absolute precision value.

Needless to say, ‘stop when our guess is not changing much’, while fine for square root, is a rather bad idea in general case. But that’s a problem from a whole other (very interesting!) field – numerical methods.

SICP Exercise 1.6

ellerain — Thu, 19 Aug 2010 19:30:54 +0000

So … unusual.

Let’s take this piece of code here:

    1     let average a b =
    2         (a + b)/2.0
    3     let improve_guess guess x =
    4         average guess x/guess

The call to average in the improve_guess procedure is being parsed into (average guess x)/guess instead of (expected by me) average guess (x/guess). These are the days of a newbie.

Anyhow.

SICP Exercise 1.6

The gist of this excercise is the same as Ex 1.5: functions evaluate their arguments as they are passed. So new-if (or, as F# prefers to call it, new_if) will force evaluation for both if_clause and else_clause before making a choice. That’s why base if is a special form! (Achievement unlocked: [Aesop Learned!]). (We can probably emulate this behavior with lazy expressions).

    1 #light
    2 namespace SICP
    3 open System
    4 
    5 module Ex1d6 = 
    6     let average a b = 
    7         (a + b)/2.0
    8 
    9     let improve_guess guess x = 
   10         average guess (x/guess)
   11 
   12     let is_good_enough (guess:double) (x:double) = 
   13         abs (guess*guess – x) < 0.0001
   14 
   15 
   16     let rec sqrt_iter guess x = 
   17         if is_good_enough guess x 
   18             then guess 
   19             else sqrt_iter (improve_guess guess x) x
   20 
   21     let new_if predicate then_clause else_clause = 
   22         match predicate with
   23         |   true -> then_clause
   24         |   _ -> else_clause
   25 
   26 
   27     let rec new_sqrt_iter guess x = 
   28         new_if (is_good_enough guess x) 
   29             guess 
   30             (new_sqrt_iter (improve_guess guess x) x)
   31 
   32     let execute = 
   33          ignore (sqrt_iter 25.0 2.0)
   34          ignore (new_sqrt_iter 25.0 2.0)

SICP Exercise 1.5

ellerain — Thu, 19 Aug 2010 19:17:13 +0000

SICP Exercise 1.5

There had to be some hacking with p and test function definitions to satisfy the static typing / type inference of F#. I opted for the easiest way:

    1 #light
    2 namespace SICP
    3 
    4 module Ex1d5 = 
    5     let rec p (x:int) :int = p x
    6 
    7     let test x y = 
    8         if x = 0 then 0 else y
    9 
   10     let execute = 
   11         test 0 (p 0)

F#, GNU Scheme and DrRacket alike are evaluating second argument when passing it to the function, so they all are using applicative order of evaluation.

Bonus level: There is a way in C# to force lazy evaluation for the function, basically telling p that it should not evaluate unless it absolutely has to. Note how static typing makes us change function signatures here.

    1 #light
    2 namespace SICP
    3 
    4 module Ex1d5BonusLevel = 
    5     let rec p (x:int) = 
    6         lazy ( let a = p x
    7                a.Value )
    8 
    9     let test x (y:Lazy) = 
   10             if x = 0 then 0 else y.Value
   11 
   12     let execute = 
   13         test 0 (p 0)

This calls for further reading:

SICP Exercise 1.4

ellerain — Thu, 19 Aug 2010 18:59:53 +0000

SICP Exercise 1.4

Now this is an interesting beast. Instead of using a result of conditional in an expression as a operand we are trying to use it as an operator. Well, F# has prefix notation for its operators as well (sorta)!

    1 #light
    2 namespace SICP
    3 
    4 module Ex1d4 = 
    5 
    6     let a_plus_abs_b a b = 
    7         ((if (b > 0) then (+) else (-)) a b)
    8 
    9     let execute = 
   10         ignore (a_plus_abs_b 3 4)
   11         ignore (a_plus_abs_b 3 -4)

That went well. A few notes:

(+) is technically a reference to the function implementing +, the infix operator.
Common Lisp also forces programmer to specifically get function from operator name
Unlike Common Lisp though, F# does not require explicit “the result of this expression is a function, call it” funcall function.
F# does not allow variadic functions (functions that can have a variable number of arguments), thus (+) is strictly int->int->int (no (+) 2 3 4 for you!)