From: Ramakrishnan Muthukrishnan <vu3rdd@gmail.com>
Date: Thu, 22 Apr 2010 13:50:39 +0000 (+0530)
Subject: Reorganisation of directory structure.
X-Git-Url: https://git.rkrishnan.org/listings/pb1client.py?a=commitdiff_plain;h=c17d779727b76c7ba664dd168f87eaa755879cc0;p=sicp.git

Reorganisation of directory structure.
---

diff --git a/chapter1/ch1_1.clj b/chapter1/ch1_1.clj
deleted file mode 100644
index 783e139..0000000
--- a/chapter1/ch1_1.clj
+++ /dev/null
@@ -1,297 +0,0 @@
-(ns sicp.chapter1.ch1_1)
-
-(defn square [x] (* x x))
-
-(defn sum-of-squares [x y]
-  (+ (square x) (square y)))
-
-(defn f [a]
-  (sum-of-squares (+ a 1) (* a 2)))
-
-(defn abs
-  "find absolute value of x"
-  [x]
-  (if (< x 0) (- x) x))
-
-(defn abs1 [x]
-  (cond (< x 0) (- x)
-	:else x))
-
-;; exercise 1.1: What is the result printed by the interpreter in response
-;;               to each expression (in order) ?
-
-(def a 3)
-(def b (+ a 1))
-
-(+ a b (* a b))  ; 19
-(= a b) ; false
-
-(if (and (> b a) (< b (* a b)))
-    b
-    a)   ; 4
-
-(cond (= a 4) 6
-      (= b 4) (+ 6 7 a)
-      :else 25)  ; 16
-
-(+ 2 (if (> b a) b a)) ; 6
-
-(* (cond (> a b) a
-	 (< a b) b
-	 :else -1)
-   (+ a 1))      ; 16
-
-;; exercise 1.2: Translate the given expression into prefix form
-(/ (+ 5 4 (- 2 (- 3 (+ 6 (/ 1 5)))))
-   (* 3 (- 6 2) (- 2 7)))  ; -71/300
-
-;; exercise 1.3:  Define a procedure that takes three numbers as
-;;                arguments and returns the sum of the squares of
-;;                the two larger numbers.
-(defn sort3 [a b c]
-  (cond (> b a) (sort3 b a c)
-	(< b c) (sort3 a c b)
-	:else [a b c]))
-
-(defn sum-of-sq-of-two-largest [a b c]
-  (apply sum-of-squares (take 2 (sort3 a b c))))
-
-;; well, I cheated above. Let me use only the constructs introduced
-;; so far in the book. (follows after the sicp meetup #2 on 28/mar/2010.
-(defn sum-of-square-of-two-largest [a b c]
-  (if (> a b)
-    (if (> b c)
-      (sum-of-squares a b) ; a > b > c
-      (sum-of-squares a c))
-    (if (> a c)
-      (sum-of-squares b a)
-      (sum-of-squares b c))))
-
-;; exercise 1.4: Observe that our model of evaluation allows for
-;;               combinations whose operators are compound
-;;               expressions. Use this observation to describe the
-;;               behavior of the following procedure:
-;; (defn a-plus-abs-b [a b]
-;;   ((if (> b 0) + -) a b))
-(comment
-  If b is positive, we do (+ a b) and if it is negative, we do (- a b).
-  This makes use of the fact that the first element in a list is an
-  operand. Here, the operand is chosen based on other operators.
-  )
-
-;; exercise 1.5:  Ben Bitdiddle has invented a test to determine
-;;                whether the interpreter he is faced with is
-;;                using applicative-order evaluation or normal-order
-;;                evaluation. He defines the following two procedures:
-;; (defn p [] (p))
-;; (defn test [x y]
-;;   (if (= x 0)
-;;    0
-;;    y))
-;;
-;; Then he evaluates the expression
-;;
-;; (test 0 (p))
-;;
-;; What behavior will Ben observe with an interpreter that uses
-;; applicative-order evaluation?
-(comment
-  In the case of applicative order evaluation, the test gets into
-  and infinite loop (eventually using all the stack), as the parameters
-  are evaluated before they are actualy used in the function.
-  )
-;; What behavior will he observe with an interpreter that uses
-;; normal-order evaluation? Explain your answer.
-(comment
-  It will print 0, as (p) is not evaluated in this case.
-  )
-
-;; 1.1.7 Square root finding using Newton's method
-(defn average [x y]
-  (/ (+ x y) 2))
-
-(defn improve [guess x]
-  (average guess (/ x guess)))
-
-(defn good-enough? [guess x]
-  (< (abs (- (square guess) x)) 0.001))
-
-(defn sqrt-iter [guess x]
-  (if (good-enough? guess x)
-    guess
-    (sqrt-iter (improve guess x)
-	       x)))
-
-(defn sqrt [x]
-  (sqrt-iter 1.0 x))
-
-;; exercise 1.6
-;; Alyssa P. Hacker doesn't see why if needs to be provided as a special form.
-;; ``Why can't I just define it as an ordinary procedure in terms of cond?''
-(defn new-if [predicate then-clause else-clause]
-  (cond predicate then-clause
-	:else else-clause))
-
-(new-if (= 3 2) 0 5)  ; 5
-(new-if (= 1 1) 0 5)  ; 0
-
-;; Delighted, Alyssa uses new-if to rewrite the square-root program:
-
-(defn sqrt-iter [guess x]
-  (new-if (good-enough? guess x)
-	  guess
-	  (sqrt-iter (improve guess x)
-		     x)))
-
-;; what happens when Alyssa attempts to use this to compute square roots? Explain.
-(comment
-  Since `new-if' is a function, when it is called from sqrt-iter, the parameters
-  are evaluated before it gets called. good-enough? will return a false unless
-  the guess and x are almost the same. guess evaluated to the initial value of
-  guess. sqrt-iter gets evaluated, but gets into an infinite loop. The predicate
-  will have no effect.)
-
-;; Exercise 1.7: The good-enough? test used in computing square roots will not
-;; be very effective for finding the square roots of very small numbers. Also,
-;; in real computers, arithmetic operations are almost always performed with
-;; limited precision. This makes our test inadequate for very large numbers.
-;; Explain these statements, with examples showing how the test fails for small
-;; and large numbers.
-(comment
- user> (sqrt (square 0.001))
- 0.031260655525445276
- user> (sqrt (square 0.2))
- 0.20060990407779591
- user> (sqrt (square 0.01))
- 0.03230844833048122
- user> (sqrt (square 0.02))
- 0.0354008825558513
- user> (sqrt (square 10))
- 10.000000000139897
- user> (sqrt (square 100))
- 100.00000025490743
- user> (sqrt (square 200))
- 200.000000510076
- user> (sqrt (square 2))
- 2.0000000929222947
- user> (sqrt (square 0.1))
- 0.10032578510960607
- user> (sqrt (square 0.01))
- 0.03230844833048122
- user> (sqrt (square 10000))
- 10000.0
- user> (sqrt (square 20000))
- 20000.0
- user> (sqrt (square 200000))
- 200000.0
- user> (sqrt (square 20000000))
- 2.0E7
- user> (sqrt (square 20000000000))
- 2.0E10
- user> (sqrt (square 200000.012))
- 200000.012
- user> (sqrt (square 2000000.123))
- 2000000.123
- user> (sqrt (square 200000000.123))
- 2.00000000123E8
- user> (sqrt (square 2000000000.123))
- 2.000000000123E9
- user> (sqrt (square 20000000000.123))
- 2.0000000000123E10
- user> (sqrt (square 2000000000000.123))
- 2.000000000000123E12
- )
-;; An alternative strategy for implementing good-enough? is to watch how guess
-;; changes from one iteration to the next and to stop when the change is a very
-;; small fraction of the guess.
-(defn sqrt-iter [old-guess new-guess x]
-  (if (good-enough? old-guess new-guess x)
-    new-guess
-    (sqrt-iter new-guess (improve new-guess x)
-	       x)))
-
-(defn improve [guess x]
-  (average guess (/ x guess)))
-
-(defn average [x y]
-  (/ (+ x y) 2))
-
-(defn good-enough? [old-guess new-guess x]
-  (< (/ (abs (- new-guess old-guess)) new-guess) 0.0001))
-
-(defn sqrt [x]
-  (sqrt-iter x 1.0 x))
-(comment
-user> (sqrt (square 0.01))
-0.010000000025490743
-user> (sqrt (square 0.001))
-0.0010000000000000117
-user> (sqrt (square 0.0001))
-1.0000000000082464E-4
-user> (sqrt (square 0.02))
-0.020000000050877154
-user> (sqrt (square 0.002))
-0.0020000000000000235
-user> (sqrt (square 4))
-4.000000000000051
-user> (sqrt (square 20))
-20.000000000298428
-user> (sqrt (square 25))
-25.000000063076968
-user> (sqrt 5)
-2.236067977499978
-user> (sqrt 25)
-5.000000000053722
-user> (sqrt 9)
-3.000000001396984
-user> (sqrt 81)
-9.000000000007091
-)
-;; exercise 1.8: cube root
-(defn cube [x]
-  (* x x x))
-
-(defn improve [guess x]
-  (/ (+ (/ x (square guess)) (* 2 guess)) 3))
-
-(defn cubert-iter [old-guess new-guess x]
-  (if (good-enough? old-guess new-guess x)
-    new-guess
-    (cubert-iter new-guess (improve new-guess x)
-		 x)))
-
-(defn cuberoot [x]
-  (cubert-iter x 1.0 x))
-
-(comment
-user> (cuberoot (cube 2))
-2.000000000012062
-user> (cuberoot (cube 10))
-10.000000000000002
-user> (cuberoot (cube 9))
-9.000000000053902
-user> (cuberoot (cube 0.001))
-0.001000000000000962
-user> (cuberoot (cube 0.0001))
-1.000000000000001E-4
-user>
-)
-;; section 1.1.8
-;; hiding the non-public procedure definitions
-(defn- sqrt-iter [guess x]
-  (if (good-enough? guess x)
-    guess
-    (sqrt-iter (improve guess x)
-	       x)))
-
-(defn- improve [guess x]
-  (average guess (/ x guess)))
-
-(defn- average [x y]
-  (/ (+ x y) 2))
-
-(defn- good-enough? [guess x]
-  (< (abs (- (square guess) x)) 0.001))
-
-(defn sqrt [x]
-  (sqrt-iter 1.0 x))
diff --git a/chapter1/ch1_2.clj b/chapter1/ch1_2.clj
deleted file mode 100644
index 13b99d1..0000000
--- a/chapter1/ch1_2.clj
+++ /dev/null
@@ -1,557 +0,0 @@
-(ns sicp.chapter1.ch1_2
-  (:use (clojure.contrib trace math)))
-
-
-(defn factorial [n]
-  (if (= n 1)
-    1
-    (* n (factorial (- n 1)))))
-
-;; stack friendly version
-(defn factorial2 [n]
-  (loop [x n acc 1] 
-    (if (= x 1)
-      acc
-      (recur (- x 1) (* acc x)))))
-
-;; even better
-(defn factorial3 [n]
-  (reduce * (range 1 (inc n))))
-
-(comment
- user> (dotrace [factorial] (factorial 3))
- TRACE t2701: (factorial 3)
- TRACE t2702: |    (factorial 2)
- TRACE t2703: |    |    (factorial 1)
- TRACE t2703: |    |    => 1
- TRACE t2702: |    => 2
- TRACE t2701: => 6
- 6
-)
-
-(comment
-  sicp.chapter1.ch1_2> (dotrace [factorial] (factorial 6))
-  TRACE t2778: (factorial 6)
-  TRACE t2779: |    (factorial 5)
-  TRACE t2780: |    |    (factorial 4)
-  TRACE t2781: |    |    |    (factorial 3)
-  TRACE t2782: |    |    |    |    (factorial 2)
-  TRACE t2783: |    |    |    |    |    (factorial 1)
-  TRACE t2783: |    |    |    |    |    => 1
-  TRACE t2782: |    |    |    |    => 2
-  TRACE t2781: |    |    |    => 6
-  TRACE t2780: |    |    => 24
-  TRACE t2779: |    => 120
-  TRACE t2778: => 720
-  720
-  )
-
-(comment
-  sicp.chapter1.ch1_2> (dotrace [factorial2] (factorial2 6))
-  TRACE t2806: (factorial2 6)
-  TRACE t2806: => 720
-  720
-  )
-
-(defn fact-iter [product counter max-count]
-  (if (> counter max-count)
-    product
-    (fact-iter (* product counter)
-	       (inc counter)
-	       max-count)))
-
-(defn factorial [n]
-  (fact-iter 1 1 n))
-
-(comment
-user> (dotrace [factorial fact-iter] (factorial 6))
-TRACE t2378: (factorial 6)
-TRACE t2379: |    (fact-iter 1 1 6)
-TRACE t2380: |    |    (fact-iter 1 2 6)
-TRACE t2381: |    |    |    (fact-iter 2 3 6)
-TRACE t2382: |    |    |    |    (fact-iter 6 4 6)
-TRACE t2383: |    |    |    |    |    (fact-iter 24 5 6)
-TRACE t2384: |    |    |    |    |    |    (fact-iter 120 6 6)
-TRACE t2385: |    |    |    |    |    |    |    (fact-iter 720 7 6)
-TRACE t2385: |    |    |    |    |    |    |    => 720
-TRACE t2384: |    |    |    |    |    |    => 720
-TRACE t2383: |    |    |    |    |    => 720
-TRACE t2382: |    |    |    |    => 720
-TRACE t2381: |    |    |    => 720
-TRACE t2380: |    |    => 720
-TRACE t2379: |    => 720
-TRACE t2378: => 720
-720
-)
-
-;; observation: clojure loop-recur construct is essentially the same as
-;; the iterative version.
-
-;; exercise 1.9
-(defn ++ [a b]
-  (if (= a 0)
-    b
-    (inc (++ (dec a) b))))
-
-(comment
-  This version is a recursive process, where the previous call increments
-  the sum by 1 and each call decrement the first operand by 1.
-  
-user> (dotrace [++] (++ 4 5))
-TRACE t3745: (++ 4 5)
-TRACE t3746: |    (++ 3 5)
-TRACE t3747: |    |    (++ 2 5)
-TRACE t3748: |    |    |    (++ 1 5)
-TRACE t3749: |    |    |    |    (++ 0 5)
-TRACE t3749: |    |    |    |    => 5
-TRACE t3748: |    |    |    => 6
-TRACE t3747: |    |    => 7
-TRACE t3746: |    => 8
-TRACE t3745: => 9
-9
-)
-(defn ++ [a b]
-  (if (= a 0)
-    b
-    (++ (dec a) (inc b))))
-
-(comment
-  
-user> (dotrace [++] (++ 4 5))
-TRACE t3766: (++ 4 5)
-TRACE t3767: |    (++ 3 6)
-TRACE t3768: |    |    (++ 2 7)
-TRACE t3769: |    |    |    (++ 1 8)
-TRACE t3770: |    |    |    |    (++ 0 9)
-TRACE t3770: |    |    |    |    => 9
-TRACE t3769: |    |    |    => 9
-TRACE t3768: |    |    => 9
-TRACE t3767: |    => 9
-TRACE t3766: => 9
-9
-)
-
-;; exercise 1.10
-;; ackerman functions
-(defn A [x y]
-  (cond (= y 0) 0
-	(= x 0) (* 2 y)
-	(= y 1) 2
-	:else (A (- x 1)
-		 (A x (- y 1)))))
-
-(comment
-user> (A 1 10)
-1024
-user> (A 2 4)
-65536
-user> (A 3 3)
-65536
-)
-
-(defn f [n] (A 0 n)) ; f(n) = 2n
-(defn g [n] (A 1 n)) ; g(n) = 2^n
-(comment
-  g (n) = A (1,n)
-        = A (0, A (1, n-1)) = f (A(1,n-1))
-	  = f (f (1,n-2)) 
-	    .....
-	    = f (f (f ... f (1,(n- (n-1)))))
-	      = f (f (f ... 2))
-		= 2 * (2^(n-1))
-		  = 2^n
-)
-
-(defn h [n] (A 2 n)) ; h(n) = 2^(n^2)
-
-;; section 1.2.2: Tree Recursion
-(defn fib [n]
-  (cond (= n 0) 0
-	(= n 1) 1
-	:else (+ (fib (- n 1))
-		 (fib (- n 2)))))
-
-;; iterative version
-(defn fib [n]
-  (fib-iter 1 0 n))
-
-(defn fib-iter [a b count]
-  (if (= count 0)
-    b
-    (fib-iter (+ a b) a (dec count))))
-
-;; example: counting changes
-(defn count-change [amount]
-  (cc amount 5))
-
-(defn cc [amount kinds-of-coins]
-  (cond (= amount 0) 1
-	(or (< amount 0) (= kinds-of-coins 0)) 0
-	:else (+ (cc amount (- kinds-of-coins 1))
-		 (cc (- amount
-			(first-denomination kinds-of-coins))
-		     kinds-of-coins))))
-
-(defn first-denomination [kinds-of-coins]
-  (cond (= kinds-of-coins 1) 1
-	(= kinds-of-coins 2) 5
-	(= kinds-of-coins 3) 10
-	(= kinds-of-coins 4) 25
-	(= kinds-of-coins 5) 50))
-
-(defn first-denomination [kinds-of-coins]
-  ({1 1 2 5 3 10 4 25 5 50} kinds-of-coins))
-
-;; exercise 1.11: A function f is defined by the rule that f(n) = n if n < 3
-;;                and f(n) = f(n - 1) + 2f(n  - 2) + 3f(n - 3) if n> 3.
-;;                Write a procedure that computes f by means of a recursive
-;;                process. Write a procedure that computes f by means of an
-;;                iterative process. 
-(defn f [n]
-  (if (< n 3)
-    n
-    (+ (f (- n 1))
-       (* 2 (f (- n 2)))
-       (* 3 (f (- n 3))))))
-
-(comment
-user> (map f (range 10))
-(0 1 2 4 11 25 59 142 335 796)  
-)
-
-;; ex 1.11: iterative version
-(defn f [n]
-  (if (< n 3)
-    n
-    (f-iter n 2 1 0)))
-
-(defn f-iter [count prev0 prev1 prev2]
-  (if (= count 3)
-    (+ prev0
-       (* 2 prev1)
-       (* 3 prev2))
-    (f-iter (dec count)
-	    (+ prev0
-	       (* 2 prev1)
-	       (* 3 prev2))
-	    prev0
-	    prev1)))
-
-;; ex 1.11: iterative version with let
-(defn f-iter [count prev0 prev1 prev2]
-  (let [res (+ prev0 (* 2 prev1) (* 3 prev2))]
-    (if (= count 3)
-      res
-      (f-iter (dec count)
-	      res
-	      prev0
-	      prev1))))
-
-;; exercise 1.12.  The following pattern of numbers is called Pascal's triangle.
-;;          1
-;;        1   1
-;;      1   2   1
-;;    1   3   3   1
-;;  1   4   6   4   1
-;; ...................
-;;
-;;                 The numbers at the edge of the triangle are all 1, and each
-;;                 number inside the triangle is the sum of the two numbers above
-;;                 it. Write a procedure that computes elements of Pascal's triangle
-;;                 by means of a recursive process. 
-(defn pascal [row col]
-  (when (<= col row)
-    (if (or (= col 0) (= row col))
-      1
-      (+ (pascal (dec row) col)
-	 (pascal (dec row) (dec col))))))
-
-;; exercise 1.13:
-(comment
-See the pdfs in the directory for the answers.
-)
-
-;; ex 1.13 (contd)
-(defn fib-approx [n]
-  (let [phi (/ (+ 1 (sqrt 5)) 2)]
-    (/ (expt phi n) (sqrt 5))))
-
-(comment
-user> (map fib-approx (range 10))
-(0.4472135954999579 0.7236067977499789 1.1708203932499368 1.8944271909999157 3.065247584249853 4.959674775249769 8.024922359499623 12.984597134749393 21.009519494249016 33.99411662899841)
-)
-
-;; exercise 1.14: tree of (count-changes 11)
-(comment
-  See the pdf for the tree representation.
-)
-
-
-;; order of size and computation
-;; see PDF, but below is the trace tree.
-(comment
-user> (use 'clojure.contrib.trace)
-nil
-user> (dotrace [count-change cc] (count-change 11))
-TRACE t2609: (count-change 11)
-TRACE t2610: |    (cc 11 5)
-TRACE t2611: |    |    (cc 11 4)
-TRACE t2612: |    |    |    (cc 11 3)
-TRACE t2613: |    |    |    |    (cc 11 2)
-TRACE t2614: |    |    |    |    |    (cc 11 1)
-TRACE t2615: |    |    |    |    |    |    (cc 11 0)
-TRACE t2615: |    |    |    |    |    |    => 0
-TRACE t2616: |    |    |    |    |    |    (cc 10 1)
-TRACE t2617: |    |    |    |    |    |    |    (cc 10 0)
-TRACE t2617: |    |    |    |    |    |    |    => 0
-TRACE t2618: |    |    |    |    |    |    |    (cc 9 1)
-TRACE t2619: |    |    |    |    |    |    |    |    (cc 9 0)
-TRACE t2619: |    |    |    |    |    |    |    |    => 0
-TRACE t2620: |    |    |    |    |    |    |    |    (cc 8 1)
-TRACE t2621: |    |    |    |    |    |    |    |    |    (cc 8 0)
-TRACE t2621: |    |    |    |    |    |    |    |    |    => 0
-TRACE t2622: |    |    |    |    |    |    |    |    |    (cc 7 1)
-TRACE t2623: |    |    |    |    |    |    |    |    |    |    (cc 7 0)
-TRACE t2623: |    |    |    |    |    |    |    |    |    |    => 0
-TRACE t2624: |    |    |    |    |    |    |    |    |    |    (cc 6 1)
-TRACE t2625: |    |    |    |    |    |    |    |    |    |    |    (cc 6 0)
-TRACE t2625: |    |    |    |    |    |    |    |    |    |    |    => 0
-TRACE t2626: |    |    |    |    |    |    |    |    |    |    |    (cc 5 1)
-TRACE t2627: |    |    |    |    |    |    |    |    |    |    |    |    (cc 5 0)
-TRACE t2627: |    |    |    |    |    |    |    |    |    |    |    |    => 0
-TRACE t2628: |    |    |    |    |    |    |    |    |    |    |    |    (cc 4 1)
-TRACE t2629: |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 4 0)
-TRACE t2629: |    |    |    |    |    |    |    |    |    |    |    |    |    => 0
-TRACE t2630: |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 3 1)
-TRACE t2631: |    |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 3 0)
-TRACE t2631: |    |    |    |    |    |    |    |    |    |    |    |    |    |    => 0
-TRACE t2632: |    |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 2 1)
-TRACE t2633: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 2 0)
-TRACE t2633: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    => 0
-TRACE t2634: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 1 1)
-TRACE t2635: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 1 0)
-TRACE t2635: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    => 0
-TRACE t2636: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 0 1)
-TRACE t2636: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    => 1
-TRACE t2634: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    => 1
-TRACE t2632: |    |    |    |    |    |    |    |    |    |    |    |    |    |    => 1
-TRACE t2630: |    |    |    |    |    |    |    |    |    |    |    |    |    => 1
-TRACE t2628: |    |    |    |    |    |    |    |    |    |    |    |    => 1
-TRACE t2626: |    |    |    |    |    |    |    |    |    |    |    => 1
-TRACE t2624: |    |    |    |    |    |    |    |    |    |    => 1
-TRACE t2622: |    |    |    |    |    |    |    |    |    => 1
-TRACE t2620: |    |    |    |    |    |    |    |    => 1
-TRACE t2618: |    |    |    |    |    |    |    => 1
-TRACE t2616: |    |    |    |    |    |    => 1
-TRACE t2614: |    |    |    |    |    => 1
-TRACE t2637: |    |    |    |    |    (cc 6 2)
-TRACE t2638: |    |    |    |    |    |    (cc 6 1)
-TRACE t2639: |    |    |    |    |    |    |    (cc 6 0)
-TRACE t2639: |    |    |    |    |    |    |    => 0
-TRACE t2640: |    |    |    |    |    |    |    (cc 5 1)
-TRACE t2641: |    |    |    |    |    |    |    |    (cc 5 0)
-TRACE t2641: |    |    |    |    |    |    |    |    => 0
-TRACE t2642: |    |    |    |    |    |    |    |    (cc 4 1)
-TRACE t2643: |    |    |    |    |    |    |    |    |    (cc 4 0)
-TRACE t2643: |    |    |    |    |    |    |    |    |    => 0
-TRACE t2644: |    |    |    |    |    |    |    |    |    (cc 3 1)
-TRACE t2645: |    |    |    |    |    |    |    |    |    |    (cc 3 0)
-TRACE t2645: |    |    |    |    |    |    |    |    |    |    => 0
-TRACE t2646: |    |    |    |    |    |    |    |    |    |    (cc 2 1)
-TRACE t2647: |    |    |    |    |    |    |    |    |    |    |    (cc 2 0)
-TRACE t2647: |    |    |    |    |    |    |    |    |    |    |    => 0
-TRACE t2648: |    |    |    |    |    |    |    |    |    |    |    (cc 1 1)
-TRACE t2649: |    |    |    |    |    |    |    |    |    |    |    |    (cc 1 0)
-TRACE t2649: |    |    |    |    |    |    |    |    |    |    |    |    => 0
-TRACE t2650: |    |    |    |    |    |    |    |    |    |    |    |    (cc 0 1)
-TRACE t2650: |    |    |    |    |    |    |    |    |    |    |    |    => 1
-TRACE t2648: |    |    |    |    |    |    |    |    |    |    |    => 1
-TRACE t2646: |    |    |    |    |    |    |    |    |    |    => 1
-TRACE t2644: |    |    |    |    |    |    |    |    |    => 1
-TRACE t2642: |    |    |    |    |    |    |    |    => 1
-TRACE t2640: |    |    |    |    |    |    |    => 1
-TRACE t2638: |    |    |    |    |    |    => 1
-TRACE t2651: |    |    |    |    |    |    (cc 1 2)
-TRACE t2652: |    |    |    |    |    |    |    (cc 1 1)
-TRACE t2653: |    |    |    |    |    |    |    |    (cc 1 0)
-TRACE t2653: |    |    |    |    |    |    |    |    => 0
-TRACE t2654: |    |    |    |    |    |    |    |    (cc 0 1)
-TRACE t2654: |    |    |    |    |    |    |    |    => 1
-TRACE t2652: |    |    |    |    |    |    |    => 1
-TRACE t2655: |    |    |    |    |    |    |    (cc -4 2)
-TRACE t2655: |    |    |    |    |    |    |    => 0
-TRACE t2651: |    |    |    |    |    |    => 1
-TRACE t2637: |    |    |    |    |    => 2
-TRACE t2613: |    |    |    |    => 3
-TRACE t2656: |    |    |    |    (cc 1 3)
-TRACE t2657: |    |    |    |    |    (cc 1 2)
-TRACE t2658: |    |    |    |    |    |    (cc 1 1)
-TRACE t2659: |    |    |    |    |    |    |    (cc 1 0)
-TRACE t2659: |    |    |    |    |    |    |    => 0
-TRACE t2660: |    |    |    |    |    |    |    (cc 0 1)
-TRACE t2660: |    |    |    |    |    |    |    => 1
-TRACE t2658: |    |    |    |    |    |    => 1
-TRACE t2661: |    |    |    |    |    |    (cc -4 2)
-TRACE t2661: |    |    |    |    |    |    => 0
-TRACE t2657: |    |    |    |    |    => 1
-TRACE t2662: |    |    |    |    |    (cc -9 3)
-TRACE t2662: |    |    |    |    |    => 0
-TRACE t2656: |    |    |    |    => 1
-TRACE t2612: |    |    |    => 4
-TRACE t2663: |    |    |    (cc -14 4)
-TRACE t2663: |    |    |    => 0
-TRACE t2611: |    |    => 4
-TRACE t2664: |    |    (cc -39 5)
-TRACE t2664: |    |    => 0
-TRACE t2610: |    => 4
-TRACE t2609: => 4
-4  
-)
-;; TODO: orders of growth in space and number of steps.
-
-
-;; exercise 1.15: sin (x) calculation
-;;    a.  How many times is the procedure p applied when (sine 12.15)
-;;        is evaluated?
-;;    b.  What is the order of growth in space and number of steps (as
-;;        a function of a) used by the process generated by the sine
-;;        procedure when (sine a) is evaluated?
-(defn cube [x] (* x x x))
-
-(defn p [x] (- (* 3 x) (* 4 (cube x))))
-
-(defn sine [angle]
-  (if (not (> (abs angle) 0.1))
-    angle
-    (p (sine (/ angle 3.0)))))
-
-;; solution to (a) => 5
-(comment
-user> (dotrace [p] (sine 12.15))
-TRACE t2490: (p 0.049999999999999996)
-TRACE t2490: => 0.1495
-TRACE t2491: (p 0.1495)
-TRACE t2491: => 0.4351345505
-TRACE t2492: (p 0.4351345505)
-TRACE t2492: => 0.9758465331678772
-TRACE t2493: (p 0.9758465331678772)
-TRACE t2493: => -0.7895631144708228
-TRACE t2494: (p -0.7895631144708228)
-TRACE t2494: => -0.39980345741334
--0.39980345741334
-)
-
-;; solution to b
-;; both space and number of steps grows as log3(a) -> log a to the base 3.
-;;
-;; proof:
-;;   a * (1/3)^n <= 0.1
-;;   => take log to the base 3 on both the sides.
-
-;; Note: Finding the order of space in a recursive process is sort of, equiv
-;;       to finding the number of deferred operations. Which is in-turn the
-;;       same as the depth of the evaluation tree.
-
-;; 1.2.4: exponentiation
-;; computing b^n
-(defn expt [b n]
-  (if (= n 0)
-    1
-    (* b (expt b (dec n)))))
-
-;; iterative
-(defn expt [b n]
-  (expt-iter b n 1))
-
-(defn expt-iter [base counter product]
-  (if (= counter 0)
-    product
-    (expt-iter b
-	       (dec counter)
-	       (* product base))))
-
-;; fast version
-(defn fast-expt [b n]
-  (cond (= n 0) 1
-	(even? n) (square (fast-expt b (/ n 2)))
-	:else (* b (fast-expt b (dec n)))))
-
-(defn even? [x]
-  (= (rem x 2) 0))
-
-(defn square [x]
-  (* x x))
-
-;; exercise 1.16:
-(defn expt [b n]
-  (expt-iter b n 1))
-
-(defn expt-iter [b n a]
-  (cond (= n 0) a
-	(even? n) (expt-iter (square b) (/ n 2) a)
-	:else (expt-iter b (- n 1) (* a b))))
-
-;; exercise 1.17:
-(defn mult [a b]
-  (if (= b 0)
-    0
-    (+ a (mult a (- b 1)))))
-
-;; product = 2 * (a * (b/2)) for even b
-;;         = a    + (a * (b - 1)) for odd b
-(defn fast-mult [a b]
-  (cond (= b 0) 0
-	(= b 1) a
-	(even? b) (twice (fast-mult a (half b)))
-	:else (+ a (fast-mult a (- b 1)))))
-
-;; double
-(defn twice [x]
-  (* 2 x))
-
-(defn half [x]
-  (/ x 2))
-
-;; exercise 1.18: iterative multiply thru addition
-;; the idea is to keep a state variable.
-(defn fast-mult-new [a b]
-  (fast-mult-iter a b 0))
-
-(defn fast-mult-iter [a b k]
-  (cond (= b 0) k
-	(even? b) (fast-mult-iter (twice a) (half b) k)
-	:else (fast-mult-iter a (- b 1) (+ k a))))
-
-(comment
-user> (dotrace [fast-mult-new fast-mult-iter] (fast-mult-new 2 3))
-TRACE t2915: (fast-mult-new 2 3)
-TRACE t2916: |    (fast-mult-iter 2 3 0)
-TRACE t2917: |    |    (fast-mult-iter 2 2 2)
-TRACE t2918: |    |    |    (fast-mult-iter 4 1 2)
-TRACE t2919: |    |    |    |    (fast-mult-iter 4 0 6)
-TRACE t2919: |    |    |    |    => 6
-TRACE t2918: |    |    |    => 6
-TRACE t2917: |    |    => 6
-TRACE t2916: |    => 6
-TRACE t2915: => 6
-6
-)
-
-;; exercise 1.19: fast fibonacci
-;; see the pdf of the notebook scan for the derivation of p' and q'
-(defn ffib [n]
-  (ffib-iter 1 0 0 1 n))
-
-(defn ffib-iter [a b p q count]
-  (cond (= count 0) b
-	(even? count)
-	(ffib-iter a
-		   b
-		   (+ (* p p) (* q q))
-		   (+ (* 2 p q) (* q q))
-		   (/ count 2))
-	:else (ffib-iter (+ (* b q) (* a q) (* a p))
-			 (+ (* b p) (* a q))
-			 p
-			 q
-			 (- count 1))))
diff --git a/misc/argue.clj b/misc/argue.clj
deleted file mode 100644
index f423b2f..0000000
--- a/misc/argue.clj
+++ /dev/null
@@ -1,12 +0,0 @@
-(ns sicp-clj)
-
-(defn argue [sentence]
-  (when-not (empty? sentence)
-    (concat (opposite (first sentence)) (argue (rest sentence)))))
-
-(defn opposite [word]
-  (cond (= word "like") "hate"
-	(= word "hate") "like"
-	(= word "wonderful") "terrible"
-	(= word "terrible") "wonderful"
-	:else word))
\ No newline at end of file
diff --git a/misc/plural.clj b/misc/plural.clj
deleted file mode 100644
index 6ded4e0..0000000
--- a/misc/plural.clj
+++ /dev/null
@@ -1,5 +0,0 @@
-;; from Brian Harvey's Spring 2008 lecture 01.
-(defn plural [wd]
-  (if (= (last wd) \y)
-    (apply str (concat (butlast wd) "ies"))
-    (apply str (concat wd "s"))))
\ No newline at end of file
diff --git a/src/main/clojure/sicp/ch1_1.clj b/src/main/clojure/sicp/ch1_1.clj
new file mode 100644
index 0000000..783e139
--- /dev/null
+++ b/src/main/clojure/sicp/ch1_1.clj
@@ -0,0 +1,297 @@
+(ns sicp.chapter1.ch1_1)
+
+(defn square [x] (* x x))
+
+(defn sum-of-squares [x y]
+  (+ (square x) (square y)))
+
+(defn f [a]
+  (sum-of-squares (+ a 1) (* a 2)))
+
+(defn abs
+  "find absolute value of x"
+  [x]
+  (if (< x 0) (- x) x))
+
+(defn abs1 [x]
+  (cond (< x 0) (- x)
+	:else x))
+
+;; exercise 1.1: What is the result printed by the interpreter in response
+;;               to each expression (in order) ?
+
+(def a 3)
+(def b (+ a 1))
+
+(+ a b (* a b))  ; 19
+(= a b) ; false
+
+(if (and (> b a) (< b (* a b)))
+    b
+    a)   ; 4
+
+(cond (= a 4) 6
+      (= b 4) (+ 6 7 a)
+      :else 25)  ; 16
+
+(+ 2 (if (> b a) b a)) ; 6
+
+(* (cond (> a b) a
+	 (< a b) b
+	 :else -1)
+   (+ a 1))      ; 16
+
+;; exercise 1.2: Translate the given expression into prefix form
+(/ (+ 5 4 (- 2 (- 3 (+ 6 (/ 1 5)))))
+   (* 3 (- 6 2) (- 2 7)))  ; -71/300
+
+;; exercise 1.3:  Define a procedure that takes three numbers as
+;;                arguments and returns the sum of the squares of
+;;                the two larger numbers.
+(defn sort3 [a b c]
+  (cond (> b a) (sort3 b a c)
+	(< b c) (sort3 a c b)
+	:else [a b c]))
+
+(defn sum-of-sq-of-two-largest [a b c]
+  (apply sum-of-squares (take 2 (sort3 a b c))))
+
+;; well, I cheated above. Let me use only the constructs introduced
+;; so far in the book. (follows after the sicp meetup #2 on 28/mar/2010.
+(defn sum-of-square-of-two-largest [a b c]
+  (if (> a b)
+    (if (> b c)
+      (sum-of-squares a b) ; a > b > c
+      (sum-of-squares a c))
+    (if (> a c)
+      (sum-of-squares b a)
+      (sum-of-squares b c))))
+
+;; exercise 1.4: Observe that our model of evaluation allows for
+;;               combinations whose operators are compound
+;;               expressions. Use this observation to describe the
+;;               behavior of the following procedure:
+;; (defn a-plus-abs-b [a b]
+;;   ((if (> b 0) + -) a b))
+(comment
+  If b is positive, we do (+ a b) and if it is negative, we do (- a b).
+  This makes use of the fact that the first element in a list is an
+  operand. Here, the operand is chosen based on other operators.
+  )
+
+;; exercise 1.5:  Ben Bitdiddle has invented a test to determine
+;;                whether the interpreter he is faced with is
+;;                using applicative-order evaluation or normal-order
+;;                evaluation. He defines the following two procedures:
+;; (defn p [] (p))
+;; (defn test [x y]
+;;   (if (= x 0)
+;;    0
+;;    y))
+;;
+;; Then he evaluates the expression
+;;
+;; (test 0 (p))
+;;
+;; What behavior will Ben observe with an interpreter that uses
+;; applicative-order evaluation?
+(comment
+  In the case of applicative order evaluation, the test gets into
+  and infinite loop (eventually using all the stack), as the parameters
+  are evaluated before they are actualy used in the function.
+  )
+;; What behavior will he observe with an interpreter that uses
+;; normal-order evaluation? Explain your answer.
+(comment
+  It will print 0, as (p) is not evaluated in this case.
+  )
+
+;; 1.1.7 Square root finding using Newton's method
+(defn average [x y]
+  (/ (+ x y) 2))
+
+(defn improve [guess x]
+  (average guess (/ x guess)))
+
+(defn good-enough? [guess x]
+  (< (abs (- (square guess) x)) 0.001))
+
+(defn sqrt-iter [guess x]
+  (if (good-enough? guess x)
+    guess
+    (sqrt-iter (improve guess x)
+	       x)))
+
+(defn sqrt [x]
+  (sqrt-iter 1.0 x))
+
+;; exercise 1.6
+;; Alyssa P. Hacker doesn't see why if needs to be provided as a special form.
+;; ``Why can't I just define it as an ordinary procedure in terms of cond?''
+(defn new-if [predicate then-clause else-clause]
+  (cond predicate then-clause
+	:else else-clause))
+
+(new-if (= 3 2) 0 5)  ; 5
+(new-if (= 1 1) 0 5)  ; 0
+
+;; Delighted, Alyssa uses new-if to rewrite the square-root program:
+
+(defn sqrt-iter [guess x]
+  (new-if (good-enough? guess x)
+	  guess
+	  (sqrt-iter (improve guess x)
+		     x)))
+
+;; what happens when Alyssa attempts to use this to compute square roots? Explain.
+(comment
+  Since `new-if' is a function, when it is called from sqrt-iter, the parameters
+  are evaluated before it gets called. good-enough? will return a false unless
+  the guess and x are almost the same. guess evaluated to the initial value of
+  guess. sqrt-iter gets evaluated, but gets into an infinite loop. The predicate
+  will have no effect.)
+
+;; Exercise 1.7: The good-enough? test used in computing square roots will not
+;; be very effective for finding the square roots of very small numbers. Also,
+;; in real computers, arithmetic operations are almost always performed with
+;; limited precision. This makes our test inadequate for very large numbers.
+;; Explain these statements, with examples showing how the test fails for small
+;; and large numbers.
+(comment
+ user> (sqrt (square 0.001))
+ 0.031260655525445276
+ user> (sqrt (square 0.2))
+ 0.20060990407779591
+ user> (sqrt (square 0.01))
+ 0.03230844833048122
+ user> (sqrt (square 0.02))
+ 0.0354008825558513
+ user> (sqrt (square 10))
+ 10.000000000139897
+ user> (sqrt (square 100))
+ 100.00000025490743
+ user> (sqrt (square 200))
+ 200.000000510076
+ user> (sqrt (square 2))
+ 2.0000000929222947
+ user> (sqrt (square 0.1))
+ 0.10032578510960607
+ user> (sqrt (square 0.01))
+ 0.03230844833048122
+ user> (sqrt (square 10000))
+ 10000.0
+ user> (sqrt (square 20000))
+ 20000.0
+ user> (sqrt (square 200000))
+ 200000.0
+ user> (sqrt (square 20000000))
+ 2.0E7
+ user> (sqrt (square 20000000000))
+ 2.0E10
+ user> (sqrt (square 200000.012))
+ 200000.012
+ user> (sqrt (square 2000000.123))
+ 2000000.123
+ user> (sqrt (square 200000000.123))
+ 2.00000000123E8
+ user> (sqrt (square 2000000000.123))
+ 2.000000000123E9
+ user> (sqrt (square 20000000000.123))
+ 2.0000000000123E10
+ user> (sqrt (square 2000000000000.123))
+ 2.000000000000123E12
+ )
+;; An alternative strategy for implementing good-enough? is to watch how guess
+;; changes from one iteration to the next and to stop when the change is a very
+;; small fraction of the guess.
+(defn sqrt-iter [old-guess new-guess x]
+  (if (good-enough? old-guess new-guess x)
+    new-guess
+    (sqrt-iter new-guess (improve new-guess x)
+	       x)))
+
+(defn improve [guess x]
+  (average guess (/ x guess)))
+
+(defn average [x y]
+  (/ (+ x y) 2))
+
+(defn good-enough? [old-guess new-guess x]
+  (< (/ (abs (- new-guess old-guess)) new-guess) 0.0001))
+
+(defn sqrt [x]
+  (sqrt-iter x 1.0 x))
+(comment
+user> (sqrt (square 0.01))
+0.010000000025490743
+user> (sqrt (square 0.001))
+0.0010000000000000117
+user> (sqrt (square 0.0001))
+1.0000000000082464E-4
+user> (sqrt (square 0.02))
+0.020000000050877154
+user> (sqrt (square 0.002))
+0.0020000000000000235
+user> (sqrt (square 4))
+4.000000000000051
+user> (sqrt (square 20))
+20.000000000298428
+user> (sqrt (square 25))
+25.000000063076968
+user> (sqrt 5)
+2.236067977499978
+user> (sqrt 25)
+5.000000000053722
+user> (sqrt 9)
+3.000000001396984
+user> (sqrt 81)
+9.000000000007091
+)
+;; exercise 1.8: cube root
+(defn cube [x]
+  (* x x x))
+
+(defn improve [guess x]
+  (/ (+ (/ x (square guess)) (* 2 guess)) 3))
+
+(defn cubert-iter [old-guess new-guess x]
+  (if (good-enough? old-guess new-guess x)
+    new-guess
+    (cubert-iter new-guess (improve new-guess x)
+		 x)))
+
+(defn cuberoot [x]
+  (cubert-iter x 1.0 x))
+
+(comment
+user> (cuberoot (cube 2))
+2.000000000012062
+user> (cuberoot (cube 10))
+10.000000000000002
+user> (cuberoot (cube 9))
+9.000000000053902
+user> (cuberoot (cube 0.001))
+0.001000000000000962
+user> (cuberoot (cube 0.0001))
+1.000000000000001E-4
+user>
+)
+;; section 1.1.8
+;; hiding the non-public procedure definitions
+(defn- sqrt-iter [guess x]
+  (if (good-enough? guess x)
+    guess
+    (sqrt-iter (improve guess x)
+	       x)))
+
+(defn- improve [guess x]
+  (average guess (/ x guess)))
+
+(defn- average [x y]
+  (/ (+ x y) 2))
+
+(defn- good-enough? [guess x]
+  (< (abs (- (square guess) x)) 0.001))
+
+(defn sqrt [x]
+  (sqrt-iter 1.0 x))
diff --git a/src/main/clojure/sicp/ch1_2.clj b/src/main/clojure/sicp/ch1_2.clj
new file mode 100644
index 0000000..13b99d1
--- /dev/null
+++ b/src/main/clojure/sicp/ch1_2.clj
@@ -0,0 +1,557 @@
+(ns sicp.chapter1.ch1_2
+  (:use (clojure.contrib trace math)))
+
+
+(defn factorial [n]
+  (if (= n 1)
+    1
+    (* n (factorial (- n 1)))))
+
+;; stack friendly version
+(defn factorial2 [n]
+  (loop [x n acc 1] 
+    (if (= x 1)
+      acc
+      (recur (- x 1) (* acc x)))))
+
+;; even better
+(defn factorial3 [n]
+  (reduce * (range 1 (inc n))))
+
+(comment
+ user> (dotrace [factorial] (factorial 3))
+ TRACE t2701: (factorial 3)
+ TRACE t2702: |    (factorial 2)
+ TRACE t2703: |    |    (factorial 1)
+ TRACE t2703: |    |    => 1
+ TRACE t2702: |    => 2
+ TRACE t2701: => 6
+ 6
+)
+
+(comment
+  sicp.chapter1.ch1_2> (dotrace [factorial] (factorial 6))
+  TRACE t2778: (factorial 6)
+  TRACE t2779: |    (factorial 5)
+  TRACE t2780: |    |    (factorial 4)
+  TRACE t2781: |    |    |    (factorial 3)
+  TRACE t2782: |    |    |    |    (factorial 2)
+  TRACE t2783: |    |    |    |    |    (factorial 1)
+  TRACE t2783: |    |    |    |    |    => 1
+  TRACE t2782: |    |    |    |    => 2
+  TRACE t2781: |    |    |    => 6
+  TRACE t2780: |    |    => 24
+  TRACE t2779: |    => 120
+  TRACE t2778: => 720
+  720
+  )
+
+(comment
+  sicp.chapter1.ch1_2> (dotrace [factorial2] (factorial2 6))
+  TRACE t2806: (factorial2 6)
+  TRACE t2806: => 720
+  720
+  )
+
+(defn fact-iter [product counter max-count]
+  (if (> counter max-count)
+    product
+    (fact-iter (* product counter)
+	       (inc counter)
+	       max-count)))
+
+(defn factorial [n]
+  (fact-iter 1 1 n))
+
+(comment
+user> (dotrace [factorial fact-iter] (factorial 6))
+TRACE t2378: (factorial 6)
+TRACE t2379: |    (fact-iter 1 1 6)
+TRACE t2380: |    |    (fact-iter 1 2 6)
+TRACE t2381: |    |    |    (fact-iter 2 3 6)
+TRACE t2382: |    |    |    |    (fact-iter 6 4 6)
+TRACE t2383: |    |    |    |    |    (fact-iter 24 5 6)
+TRACE t2384: |    |    |    |    |    |    (fact-iter 120 6 6)
+TRACE t2385: |    |    |    |    |    |    |    (fact-iter 720 7 6)
+TRACE t2385: |    |    |    |    |    |    |    => 720
+TRACE t2384: |    |    |    |    |    |    => 720
+TRACE t2383: |    |    |    |    |    => 720
+TRACE t2382: |    |    |    |    => 720
+TRACE t2381: |    |    |    => 720
+TRACE t2380: |    |    => 720
+TRACE t2379: |    => 720
+TRACE t2378: => 720
+720
+)
+
+;; observation: clojure loop-recur construct is essentially the same as
+;; the iterative version.
+
+;; exercise 1.9
+(defn ++ [a b]
+  (if (= a 0)
+    b
+    (inc (++ (dec a) b))))
+
+(comment
+  This version is a recursive process, where the previous call increments
+  the sum by 1 and each call decrement the first operand by 1.
+  
+user> (dotrace [++] (++ 4 5))
+TRACE t3745: (++ 4 5)
+TRACE t3746: |    (++ 3 5)
+TRACE t3747: |    |    (++ 2 5)
+TRACE t3748: |    |    |    (++ 1 5)
+TRACE t3749: |    |    |    |    (++ 0 5)
+TRACE t3749: |    |    |    |    => 5
+TRACE t3748: |    |    |    => 6
+TRACE t3747: |    |    => 7
+TRACE t3746: |    => 8
+TRACE t3745: => 9
+9
+)
+(defn ++ [a b]
+  (if (= a 0)
+    b
+    (++ (dec a) (inc b))))
+
+(comment
+  
+user> (dotrace [++] (++ 4 5))
+TRACE t3766: (++ 4 5)
+TRACE t3767: |    (++ 3 6)
+TRACE t3768: |    |    (++ 2 7)
+TRACE t3769: |    |    |    (++ 1 8)
+TRACE t3770: |    |    |    |    (++ 0 9)
+TRACE t3770: |    |    |    |    => 9
+TRACE t3769: |    |    |    => 9
+TRACE t3768: |    |    => 9
+TRACE t3767: |    => 9
+TRACE t3766: => 9
+9
+)
+
+;; exercise 1.10
+;; ackerman functions
+(defn A [x y]
+  (cond (= y 0) 0
+	(= x 0) (* 2 y)
+	(= y 1) 2
+	:else (A (- x 1)
+		 (A x (- y 1)))))
+
+(comment
+user> (A 1 10)
+1024
+user> (A 2 4)
+65536
+user> (A 3 3)
+65536
+)
+
+(defn f [n] (A 0 n)) ; f(n) = 2n
+(defn g [n] (A 1 n)) ; g(n) = 2^n
+(comment
+  g (n) = A (1,n)
+        = A (0, A (1, n-1)) = f (A(1,n-1))
+	  = f (f (1,n-2)) 
+	    .....
+	    = f (f (f ... f (1,(n- (n-1)))))
+	      = f (f (f ... 2))
+		= 2 * (2^(n-1))
+		  = 2^n
+)
+
+(defn h [n] (A 2 n)) ; h(n) = 2^(n^2)
+
+;; section 1.2.2: Tree Recursion
+(defn fib [n]
+  (cond (= n 0) 0
+	(= n 1) 1
+	:else (+ (fib (- n 1))
+		 (fib (- n 2)))))
+
+;; iterative version
+(defn fib [n]
+  (fib-iter 1 0 n))
+
+(defn fib-iter [a b count]
+  (if (= count 0)
+    b
+    (fib-iter (+ a b) a (dec count))))
+
+;; example: counting changes
+(defn count-change [amount]
+  (cc amount 5))
+
+(defn cc [amount kinds-of-coins]
+  (cond (= amount 0) 1
+	(or (< amount 0) (= kinds-of-coins 0)) 0
+	:else (+ (cc amount (- kinds-of-coins 1))
+		 (cc (- amount
+			(first-denomination kinds-of-coins))
+		     kinds-of-coins))))
+
+(defn first-denomination [kinds-of-coins]
+  (cond (= kinds-of-coins 1) 1
+	(= kinds-of-coins 2) 5
+	(= kinds-of-coins 3) 10
+	(= kinds-of-coins 4) 25
+	(= kinds-of-coins 5) 50))
+
+(defn first-denomination [kinds-of-coins]
+  ({1 1 2 5 3 10 4 25 5 50} kinds-of-coins))
+
+;; exercise 1.11: A function f is defined by the rule that f(n) = n if n < 3
+;;                and f(n) = f(n - 1) + 2f(n  - 2) + 3f(n - 3) if n> 3.
+;;                Write a procedure that computes f by means of a recursive
+;;                process. Write a procedure that computes f by means of an
+;;                iterative process. 
+(defn f [n]
+  (if (< n 3)
+    n
+    (+ (f (- n 1))
+       (* 2 (f (- n 2)))
+       (* 3 (f (- n 3))))))
+
+(comment
+user> (map f (range 10))
+(0 1 2 4 11 25 59 142 335 796)  
+)
+
+;; ex 1.11: iterative version
+(defn f [n]
+  (if (< n 3)
+    n
+    (f-iter n 2 1 0)))
+
+(defn f-iter [count prev0 prev1 prev2]
+  (if (= count 3)
+    (+ prev0
+       (* 2 prev1)
+       (* 3 prev2))
+    (f-iter (dec count)
+	    (+ prev0
+	       (* 2 prev1)
+	       (* 3 prev2))
+	    prev0
+	    prev1)))
+
+;; ex 1.11: iterative version with let
+(defn f-iter [count prev0 prev1 prev2]
+  (let [res (+ prev0 (* 2 prev1) (* 3 prev2))]
+    (if (= count 3)
+      res
+      (f-iter (dec count)
+	      res
+	      prev0
+	      prev1))))
+
+;; exercise 1.12.  The following pattern of numbers is called Pascal's triangle.
+;;          1
+;;        1   1
+;;      1   2   1
+;;    1   3   3   1
+;;  1   4   6   4   1
+;; ...................
+;;
+;;                 The numbers at the edge of the triangle are all 1, and each
+;;                 number inside the triangle is the sum of the two numbers above
+;;                 it. Write a procedure that computes elements of Pascal's triangle
+;;                 by means of a recursive process. 
+(defn pascal [row col]
+  (when (<= col row)
+    (if (or (= col 0) (= row col))
+      1
+      (+ (pascal (dec row) col)
+	 (pascal (dec row) (dec col))))))
+
+;; exercise 1.13:
+(comment
+See the pdfs in the directory for the answers.
+)
+
+;; ex 1.13 (contd)
+(defn fib-approx [n]
+  (let [phi (/ (+ 1 (sqrt 5)) 2)]
+    (/ (expt phi n) (sqrt 5))))
+
+(comment
+user> (map fib-approx (range 10))
+(0.4472135954999579 0.7236067977499789 1.1708203932499368 1.8944271909999157 3.065247584249853 4.959674775249769 8.024922359499623 12.984597134749393 21.009519494249016 33.99411662899841)
+)
+
+;; exercise 1.14: tree of (count-changes 11)
+(comment
+  See the pdf for the tree representation.
+)
+
+
+;; order of size and computation
+;; see PDF, but below is the trace tree.
+(comment
+user> (use 'clojure.contrib.trace)
+nil
+user> (dotrace [count-change cc] (count-change 11))
+TRACE t2609: (count-change 11)
+TRACE t2610: |    (cc 11 5)
+TRACE t2611: |    |    (cc 11 4)
+TRACE t2612: |    |    |    (cc 11 3)
+TRACE t2613: |    |    |    |    (cc 11 2)
+TRACE t2614: |    |    |    |    |    (cc 11 1)
+TRACE t2615: |    |    |    |    |    |    (cc 11 0)
+TRACE t2615: |    |    |    |    |    |    => 0
+TRACE t2616: |    |    |    |    |    |    (cc 10 1)
+TRACE t2617: |    |    |    |    |    |    |    (cc 10 0)
+TRACE t2617: |    |    |    |    |    |    |    => 0
+TRACE t2618: |    |    |    |    |    |    |    (cc 9 1)
+TRACE t2619: |    |    |    |    |    |    |    |    (cc 9 0)
+TRACE t2619: |    |    |    |    |    |    |    |    => 0
+TRACE t2620: |    |    |    |    |    |    |    |    (cc 8 1)
+TRACE t2621: |    |    |    |    |    |    |    |    |    (cc 8 0)
+TRACE t2621: |    |    |    |    |    |    |    |    |    => 0
+TRACE t2622: |    |    |    |    |    |    |    |    |    (cc 7 1)
+TRACE t2623: |    |    |    |    |    |    |    |    |    |    (cc 7 0)
+TRACE t2623: |    |    |    |    |    |    |    |    |    |    => 0
+TRACE t2624: |    |    |    |    |    |    |    |    |    |    (cc 6 1)
+TRACE t2625: |    |    |    |    |    |    |    |    |    |    |    (cc 6 0)
+TRACE t2625: |    |    |    |    |    |    |    |    |    |    |    => 0
+TRACE t2626: |    |    |    |    |    |    |    |    |    |    |    (cc 5 1)
+TRACE t2627: |    |    |    |    |    |    |    |    |    |    |    |    (cc 5 0)
+TRACE t2627: |    |    |    |    |    |    |    |    |    |    |    |    => 0
+TRACE t2628: |    |    |    |    |    |    |    |    |    |    |    |    (cc 4 1)
+TRACE t2629: |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 4 0)
+TRACE t2629: |    |    |    |    |    |    |    |    |    |    |    |    |    => 0
+TRACE t2630: |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 3 1)
+TRACE t2631: |    |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 3 0)
+TRACE t2631: |    |    |    |    |    |    |    |    |    |    |    |    |    |    => 0
+TRACE t2632: |    |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 2 1)
+TRACE t2633: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 2 0)
+TRACE t2633: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    => 0
+TRACE t2634: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 1 1)
+TRACE t2635: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 1 0)
+TRACE t2635: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    => 0
+TRACE t2636: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    (cc 0 1)
+TRACE t2636: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    => 1
+TRACE t2634: |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    => 1
+TRACE t2632: |    |    |    |    |    |    |    |    |    |    |    |    |    |    => 1
+TRACE t2630: |    |    |    |    |    |    |    |    |    |    |    |    |    => 1
+TRACE t2628: |    |    |    |    |    |    |    |    |    |    |    |    => 1
+TRACE t2626: |    |    |    |    |    |    |    |    |    |    |    => 1
+TRACE t2624: |    |    |    |    |    |    |    |    |    |    => 1
+TRACE t2622: |    |    |    |    |    |    |    |    |    => 1
+TRACE t2620: |    |    |    |    |    |    |    |    => 1
+TRACE t2618: |    |    |    |    |    |    |    => 1
+TRACE t2616: |    |    |    |    |    |    => 1
+TRACE t2614: |    |    |    |    |    => 1
+TRACE t2637: |    |    |    |    |    (cc 6 2)
+TRACE t2638: |    |    |    |    |    |    (cc 6 1)
+TRACE t2639: |    |    |    |    |    |    |    (cc 6 0)
+TRACE t2639: |    |    |    |    |    |    |    => 0
+TRACE t2640: |    |    |    |    |    |    |    (cc 5 1)
+TRACE t2641: |    |    |    |    |    |    |    |    (cc 5 0)
+TRACE t2641: |    |    |    |    |    |    |    |    => 0
+TRACE t2642: |    |    |    |    |    |    |    |    (cc 4 1)
+TRACE t2643: |    |    |    |    |    |    |    |    |    (cc 4 0)
+TRACE t2643: |    |    |    |    |    |    |    |    |    => 0
+TRACE t2644: |    |    |    |    |    |    |    |    |    (cc 3 1)
+TRACE t2645: |    |    |    |    |    |    |    |    |    |    (cc 3 0)
+TRACE t2645: |    |    |    |    |    |    |    |    |    |    => 0
+TRACE t2646: |    |    |    |    |    |    |    |    |    |    (cc 2 1)
+TRACE t2647: |    |    |    |    |    |    |    |    |    |    |    (cc 2 0)
+TRACE t2647: |    |    |    |    |    |    |    |    |    |    |    => 0
+TRACE t2648: |    |    |    |    |    |    |    |    |    |    |    (cc 1 1)
+TRACE t2649: |    |    |    |    |    |    |    |    |    |    |    |    (cc 1 0)
+TRACE t2649: |    |    |    |    |    |    |    |    |    |    |    |    => 0
+TRACE t2650: |    |    |    |    |    |    |    |    |    |    |    |    (cc 0 1)
+TRACE t2650: |    |    |    |    |    |    |    |    |    |    |    |    => 1
+TRACE t2648: |    |    |    |    |    |    |    |    |    |    |    => 1
+TRACE t2646: |    |    |    |    |    |    |    |    |    |    => 1
+TRACE t2644: |    |    |    |    |    |    |    |    |    => 1
+TRACE t2642: |    |    |    |    |    |    |    |    => 1
+TRACE t2640: |    |    |    |    |    |    |    => 1
+TRACE t2638: |    |    |    |    |    |    => 1
+TRACE t2651: |    |    |    |    |    |    (cc 1 2)
+TRACE t2652: |    |    |    |    |    |    |    (cc 1 1)
+TRACE t2653: |    |    |    |    |    |    |    |    (cc 1 0)
+TRACE t2653: |    |    |    |    |    |    |    |    => 0
+TRACE t2654: |    |    |    |    |    |    |    |    (cc 0 1)
+TRACE t2654: |    |    |    |    |    |    |    |    => 1
+TRACE t2652: |    |    |    |    |    |    |    => 1
+TRACE t2655: |    |    |    |    |    |    |    (cc -4 2)
+TRACE t2655: |    |    |    |    |    |    |    => 0
+TRACE t2651: |    |    |    |    |    |    => 1
+TRACE t2637: |    |    |    |    |    => 2
+TRACE t2613: |    |    |    |    => 3
+TRACE t2656: |    |    |    |    (cc 1 3)
+TRACE t2657: |    |    |    |    |    (cc 1 2)
+TRACE t2658: |    |    |    |    |    |    (cc 1 1)
+TRACE t2659: |    |    |    |    |    |    |    (cc 1 0)
+TRACE t2659: |    |    |    |    |    |    |    => 0
+TRACE t2660: |    |    |    |    |    |    |    (cc 0 1)
+TRACE t2660: |    |    |    |    |    |    |    => 1
+TRACE t2658: |    |    |    |    |    |    => 1
+TRACE t2661: |    |    |    |    |    |    (cc -4 2)
+TRACE t2661: |    |    |    |    |    |    => 0
+TRACE t2657: |    |    |    |    |    => 1
+TRACE t2662: |    |    |    |    |    (cc -9 3)
+TRACE t2662: |    |    |    |    |    => 0
+TRACE t2656: |    |    |    |    => 1
+TRACE t2612: |    |    |    => 4
+TRACE t2663: |    |    |    (cc -14 4)
+TRACE t2663: |    |    |    => 0
+TRACE t2611: |    |    => 4
+TRACE t2664: |    |    (cc -39 5)
+TRACE t2664: |    |    => 0
+TRACE t2610: |    => 4
+TRACE t2609: => 4
+4  
+)
+;; TODO: orders of growth in space and number of steps.
+
+
+;; exercise 1.15: sin (x) calculation
+;;    a.  How many times is the procedure p applied when (sine 12.15)
+;;        is evaluated?
+;;    b.  What is the order of growth in space and number of steps (as
+;;        a function of a) used by the process generated by the sine
+;;        procedure when (sine a) is evaluated?
+(defn cube [x] (* x x x))
+
+(defn p [x] (- (* 3 x) (* 4 (cube x))))
+
+(defn sine [angle]
+  (if (not (> (abs angle) 0.1))
+    angle
+    (p (sine (/ angle 3.0)))))
+
+;; solution to (a) => 5
+(comment
+user> (dotrace [p] (sine 12.15))
+TRACE t2490: (p 0.049999999999999996)
+TRACE t2490: => 0.1495
+TRACE t2491: (p 0.1495)
+TRACE t2491: => 0.4351345505
+TRACE t2492: (p 0.4351345505)
+TRACE t2492: => 0.9758465331678772
+TRACE t2493: (p 0.9758465331678772)
+TRACE t2493: => -0.7895631144708228
+TRACE t2494: (p -0.7895631144708228)
+TRACE t2494: => -0.39980345741334
+-0.39980345741334
+)
+
+;; solution to b
+;; both space and number of steps grows as log3(a) -> log a to the base 3.
+;;
+;; proof:
+;;   a * (1/3)^n <= 0.1
+;;   => take log to the base 3 on both the sides.
+
+;; Note: Finding the order of space in a recursive process is sort of, equiv
+;;       to finding the number of deferred operations. Which is in-turn the
+;;       same as the depth of the evaluation tree.
+
+;; 1.2.4: exponentiation
+;; computing b^n
+(defn expt [b n]
+  (if (= n 0)
+    1
+    (* b (expt b (dec n)))))
+
+;; iterative
+(defn expt [b n]
+  (expt-iter b n 1))
+
+(defn expt-iter [base counter product]
+  (if (= counter 0)
+    product
+    (expt-iter b
+	       (dec counter)
+	       (* product base))))
+
+;; fast version
+(defn fast-expt [b n]
+  (cond (= n 0) 1
+	(even? n) (square (fast-expt b (/ n 2)))
+	:else (* b (fast-expt b (dec n)))))
+
+(defn even? [x]
+  (= (rem x 2) 0))
+
+(defn square [x]
+  (* x x))
+
+;; exercise 1.16:
+(defn expt [b n]
+  (expt-iter b n 1))
+
+(defn expt-iter [b n a]
+  (cond (= n 0) a
+	(even? n) (expt-iter (square b) (/ n 2) a)
+	:else (expt-iter b (- n 1) (* a b))))
+
+;; exercise 1.17:
+(defn mult [a b]
+  (if (= b 0)
+    0
+    (+ a (mult a (- b 1)))))
+
+;; product = 2 * (a * (b/2)) for even b
+;;         = a    + (a * (b - 1)) for odd b
+(defn fast-mult [a b]
+  (cond (= b 0) 0
+	(= b 1) a
+	(even? b) (twice (fast-mult a (half b)))
+	:else (+ a (fast-mult a (- b 1)))))
+
+;; double
+(defn twice [x]
+  (* 2 x))
+
+(defn half [x]
+  (/ x 2))
+
+;; exercise 1.18: iterative multiply thru addition
+;; the idea is to keep a state variable.
+(defn fast-mult-new [a b]
+  (fast-mult-iter a b 0))
+
+(defn fast-mult-iter [a b k]
+  (cond (= b 0) k
+	(even? b) (fast-mult-iter (twice a) (half b) k)
+	:else (fast-mult-iter a (- b 1) (+ k a))))
+
+(comment
+user> (dotrace [fast-mult-new fast-mult-iter] (fast-mult-new 2 3))
+TRACE t2915: (fast-mult-new 2 3)
+TRACE t2916: |    (fast-mult-iter 2 3 0)
+TRACE t2917: |    |    (fast-mult-iter 2 2 2)
+TRACE t2918: |    |    |    (fast-mult-iter 4 1 2)
+TRACE t2919: |    |    |    |    (fast-mult-iter 4 0 6)
+TRACE t2919: |    |    |    |    => 6
+TRACE t2918: |    |    |    => 6
+TRACE t2917: |    |    => 6
+TRACE t2916: |    => 6
+TRACE t2915: => 6
+6
+)
+
+;; exercise 1.19: fast fibonacci
+;; see the pdf of the notebook scan for the derivation of p' and q'
+(defn ffib [n]
+  (ffib-iter 1 0 0 1 n))
+
+(defn ffib-iter [a b p q count]
+  (cond (= count 0) b
+	(even? count)
+	(ffib-iter a
+		   b
+		   (+ (* p p) (* q q))
+		   (+ (* 2 p q) (* q q))
+		   (/ count 2))
+	:else (ffib-iter (+ (* b q) (* a q) (* a p))
+			 (+ (* b p) (* a q))
+			 p
+			 q
+			 (- count 1))))
diff --git a/src/main/clojure/sicp/misc/argue.clj b/src/main/clojure/sicp/misc/argue.clj
new file mode 100644
index 0000000..f423b2f
--- /dev/null
+++ b/src/main/clojure/sicp/misc/argue.clj
@@ -0,0 +1,12 @@
+(ns sicp-clj)
+
+(defn argue [sentence]
+  (when-not (empty? sentence)
+    (concat (opposite (first sentence)) (argue (rest sentence)))))
+
+(defn opposite [word]
+  (cond (= word "like") "hate"
+	(= word "hate") "like"
+	(= word "wonderful") "terrible"
+	(= word "terrible") "wonderful"
+	:else word))
\ No newline at end of file
diff --git a/src/main/clojure/sicp/misc/plural.clj b/src/main/clojure/sicp/misc/plural.clj
new file mode 100644
index 0000000..6ded4e0
--- /dev/null
+++ b/src/main/clojure/sicp/misc/plural.clj
@@ -0,0 +1,5 @@
+;; from Brian Harvey's Spring 2008 lecture 01.
+(defn plural [wd]
+  (if (= (last wd) \y)
+    (apply str (concat (butlast wd) "ies"))
+    (apply str (concat wd "s"))))
\ No newline at end of file