View source

==Exercise 1.31 From SICP in Haskell==

[http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-12.html#%_sec_1.3 Details from SICP are here]

a.  The '''(sum)''' procedure is only the simplest of a vast number of similar abstractions that can be captured as higher-order procedures.[http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-12.html#footnote_Temp_9 55] Write an analogous procedure called '''(product)''' that returns the product of the values of a function at points over a given range. Show how to define '''(factorial)''' in terms of '''(product)'''. Also use '''(product)''' to compute approximations to  <math>\pi</math> using the formula [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-12.html#footnote_Temp_96 52]

<math>\frac{\pi}{4} = \frac{2\cdot4\cdot4\cdot6\cdot6\cdot8\ldots}{3\cdot3\cdot5\cdot5\cdot7\cdot7\ldots}</math>


b.  If your '''(product)''' procedure generates a recursive process, write one that generates an iterative process. If it generates an iterative process, write one that generates a recursive process. 

==Attempt==

===Part a===

Please read through the [[SICP-2nd-Edition-Exercise-1.31| Scheme version of this exercise to see my train of thought]]

I found this exercise quite hard in Haskell. This was due to me struggling with trying to understand the way Haskell handles types etc. So far, for me, it appears that Haskells strong typing is a real pain to use. I cannot relate it to anything I have done in the past so it's taking some getting used to. 

I'm hoping that I learn more Haskell this gets a lot easier. If it doesn't then I think I may need to try a language other than Haskell to do this in.

I also noticed that DrScheme computed the result a lot faster than Haskell and used a lot less RAM. For really big numbers Haskell would run out of stack space rapidly. If I increased it it took a long time to run. I think this could be attributed to my rubbish Haskell skills. I will take another attempt at this to remove the temporary variables etc. I think the way i have written this is  recursive rather than iterative hence the problems.

===Part b===

Please look in the book at the recursive sum algorithm.

==Haskell==
<source lang="haskell" line start=1>
module Main where
import Text.Printf
--jw :: Integer -> Integer
--accumulator :: (Integer -> Integer) -> Integer -> Integer -> (Integer -> Integer) -> (Integer -> Integer) -> Integer -> Integer
jwp  :: Double -> Double
jwn  :: Double -> Double
accumulator :: (Double -> Double) -> Double -> Double -> (Double -> Double) -> (Double -> Double) -> Double -> Double

main =
  do
    let result = (johnwallis (2::Double) 200000) * 4.0
    printf "\n"
    printf "\tresult==%f\n" result
    printf "\n"

johnwallis a b =
  let
    ap  = a + 2
    inc  x = x
    step y = y + 2
  in
    (jwstratp a b inc step 1 ) * (jwstratn ap b inc step 1 )

jwp n = n/(n + 1.0)
jwn n = n/(n - 1.0)

jwstratp = accumulator jwp
jwstratn = accumulator jwn


accumulator op a b incr stepper acc =
  let
    p  = acc * (op (incr a))
    a1 = stepper a
  in
    if a1 > b
      then p
      else accumulator op a1 b incr stepper p
</source>

==Parent Course==

[[6.001_Structure_and_Interpretation_of_Computer_Programs]]

==Further Reading==

[[SICP-2nd-Edition-Exercise-1.31| Scheme version of this exercise]]