From: Ramakrishnan Muthukrishnan Date: Tue, 4 May 2010 09:54:06 +0000 (+0530) Subject: namespace confusions resolved. X-Git-Url: https://git.rkrishnan.org/?a=commitdiff_plain;h=72cc7c9ba92d6f5668e95f00b47acd08952f371c;p=sicp.git namespace confusions resolved. --- diff --git a/src/sicp/ch1_3.clj b/src/sicp/ch1_3.clj new file mode 100644 index 0000000..0cf7b28 --- /dev/null +++ b/src/sicp/ch1_3.clj @@ -0,0 +1,43 @@ + +(ns sicp.ch1-3 + (:use [sicp utils] + [clojure.contrib test-is])) + +;; 1.3.1: Procedures as arguments +(defn sum-integers [a b] + (if (> a b) + 0 + (+ a (sum-integers (+ a 1) b)))) + +(defn sum-cubes [a b] + (if (> a b) + 0 + (+ (cube a) (sum-cubes (+ a 1) b)))) + +(defn pi-sum [a b] + (if (> a b) + 0 + (+ (/ 1.0 (* a (+ a 2))) (pi-sum (+ a 1) b)))) + +(defn sum [term a next b] + (if (> a b) + 0 + (+ (term a) + (sum term (next a) next b)))) + +(def sum-cubes-new (fn[a b] (sum cube a inc b))) + +(deftest test-sum-of-first-10-integers + (is (sum #(identity %) 1 inc 10) 55)) + +;; (* (sum #(/ 1.0 (* % (+ % 2))) 1 #(+ % 4) 1000) 8) +;;=> 3.139592655589783 (approaches PI) + +(defn integral [f a b dx] + (* (sum f (+ a (/ dx 2)) #(+ % dx) b) + dx)) + +(integral cube 0 1 0.001) +;;=>0.249999875000001 +(integral cube 0 1 0.005) +;;=>0.24999687500000028 \ No newline at end of file diff --git a/src/sicp/ex1_1.clj b/src/sicp/ex1_1.clj new file mode 100644 index 0000000..ad9b8de --- /dev/null +++ b/src/sicp/ex1_1.clj @@ -0,0 +1,27 @@ +(ns sicp.ex1_1 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; 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 diff --git a/src/sicp/ex1_10.clj b/src/sicp/ex1_10.clj new file mode 100644 index 0000000..413e30c --- /dev/null +++ b/src/sicp/ex1_10.clj @@ -0,0 +1,36 @@ +(ns sicp.ex1_10 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; 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) diff --git a/src/sicp/ex1_11.clj b/src/sicp/ex1_11.clj new file mode 100644 index 0000000..d76c807 --- /dev/null +++ b/src/sicp/ex1_11.clj @@ -0,0 +1,48 @@ +(ns sicp.ex1_11 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; 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-iter [count prev0 prev1 prev2] + (if (= count 3) + (+ prev0 + (* 2 prev1) + (* 3 prev2)) + (f-iter (dec count) + (+ prev0 + (* 2 prev1) + (* 3 prev2)) + prev0 + prev1))) + +(defn f [n] + (if (< n 3) + n + (f-iter n 2 1 0))) + +;; 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)))) diff --git a/src/sicp/ex1_12.clj b/src/sicp/ex1_12.clj new file mode 100644 index 0000000..ff3e39a --- /dev/null +++ b/src/sicp/ex1_12.clj @@ -0,0 +1,22 @@ +(ns sicp.ex1_12 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; 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)))))) diff --git a/src/sicp/ex1_13.clj b/src/sicp/ex1_13.clj new file mode 100644 index 0000000..e9b1fd7 --- /dev/null +++ b/src/sicp/ex1_13.clj @@ -0,0 +1,18 @@ +(ns sicp.ex1_13 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; 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) +;; ) diff --git a/src/sicp/ex1_14.clj b/src/sicp/ex1_14.clj new file mode 100644 index 0000000..a3df2aa --- /dev/null +++ b/src/sicp/ex1_14.clj @@ -0,0 +1,133 @@ +(ns sicp.ex1_14 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; exercise 1.14: tree of (count-changes 11) +(comment + See the notebook (sorry, don't have the time to scan it and put it on the web) + 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. diff --git a/src/sicp/ex1_15.clj b/src/sicp/ex1_15.clj new file mode 100644 index 0000000..11249f5 --- /dev/null +++ b/src/sicp/ex1_15.clj @@ -0,0 +1,43 @@ +(ns sicp.ex1_15 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; 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 p [x] (- (* 3 x) (* 4 (cube x)))) + +(defn sine [angle] + (if (not (> (myabs 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. diff --git a/src/sicp/ex1_16.clj b/src/sicp/ex1_16.clj new file mode 100644 index 0000000..9bc774a --- /dev/null +++ b/src/sicp/ex1_16.clj @@ -0,0 +1,12 @@ +(ns sicp.ex1_16 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; exercise 1.16: +(defn myexpt [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)))) diff --git a/src/sicp/ex1_17.clj b/src/sicp/ex1_17.clj new file mode 100644 index 0000000..ac057e0 --- /dev/null +++ b/src/sicp/ex1_17.clj @@ -0,0 +1,18 @@ +(ns sicp.ex1_17 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; exercise 1.17: +(defn mult [a b] + (if (= b 0) + 0 + (+ a (mult a (- b 1))))) + +;; double +;; 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))))) diff --git a/src/sicp/ex1_18.clj b/src/sicp/ex1_18.clj new file mode 100644 index 0000000..7e45dd1 --- /dev/null +++ b/src/sicp/ex1_18.clj @@ -0,0 +1,28 @@ +(ns sicp.ex1_18 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; exercise 1.18: iterative multiply thru addition +;; the idea is to keep a state variable. +(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)))) + +(defn fast-mult-new [a b] + (fast-mult-iter a b 0)) + +;; (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 +;; ) diff --git a/src/sicp/ex1_19.clj b/src/sicp/ex1_19.clj new file mode 100644 index 0000000..06ab367 --- /dev/null +++ b/src/sicp/ex1_19.clj @@ -0,0 +1,22 @@ +(ns sicp.ex1_19 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; exercise 1.19: fast fibonacci +;; see the pdf of the notebook scan for the derivation of p' and q' +(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)))) + +(defn ffib [n] + (ffib-iter 1 0 0 1 n)) diff --git a/src/sicp/ex1_2.clj b/src/sicp/ex1_2.clj new file mode 100644 index 0000000..2fae959 --- /dev/null +++ b/src/sicp/ex1_2.clj @@ -0,0 +1,7 @@ +(ns sicp.ex1_2 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; exercise 1.2: Translate the given expression into prefix form +(/ (+ 5 4 (- 2 (- 3 (+ 6 (/ 1 5))))) + (* 3 (- 6 2) (- 2 7))) ; -71/300 diff --git a/src/sicp/ex1_20.clj b/src/sicp/ex1_20.clj new file mode 100644 index 0000000..a7d0a62 --- /dev/null +++ b/src/sicp/ex1_20.clj @@ -0,0 +1,10 @@ +(ns sicp.ex1_20 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;;; exercise 1.20. +;; +;; normal order - 18, applicative order - 4. +;; +;; too lazy to scan things from the notebook. May be I should instead +;; use a wiki. diff --git a/src/sicp/ex1_21.clj b/src/sicp/ex1_21.clj new file mode 100644 index 0000000..af6d91b --- /dev/null +++ b/src/sicp/ex1_21.clj @@ -0,0 +1,13 @@ +(ns sicp.ex1_21 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; exercise 1.21 +(comment +user> (smallest-divisor 199) +199 +user> (smallest-divisor 1999) +1999 +user> (smallest-divisor 19999) +7 +) diff --git a/src/sicp/ex1_22.clj b/src/sicp/ex1_22.clj new file mode 100644 index 0000000..daf7815 --- /dev/null +++ b/src/sicp/ex1_22.clj @@ -0,0 +1,112 @@ +(ns sicp.ex1_22 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; exercise 1.22 +(defn timed-prime-test [n] + (prn) + (print n) + (start-prime-test n (System/nanoTime))) + +(defn start-prime-test [n start-time] + (if (prime? n) + (report-prime (- (System/nanoTime) start-time)))) + +(defn report-prime [elapsed-time] + (print " *** ") + (print elapsed-time)) + +(defn search-for-primes [a b] + (cond (>= a b) nil + (even? a) (search-for-primes (+ 1 a) b) + (timed-prime-test a) (search-for-primes (+ 2 a) b) + :else (search-for-primes (+ 2 a) b))) + +;;; three smallest primes greater than 1000 +;;; 1009, 1013, 1019 +(take 3 (filter #(prime? %) (iterate inc 1000))) +;=> (1009 1013 1019) + +;=> 0.9642028750000001 + +;;; > 10,000: 10007, 10009, 10037 +(take 3 (filter #(prime? %) (iterate inc 10000))) +;=> (10007 10009 10037) + +;=> 1.5897884999999998 + +;;; > 100,000: 100003, 100019, 100043 +(take 3 (filter #(prime? %) (iterate inc 100000))) +;=> (100003 100019 100043) + +;=> 1.8525091250000003 + +;;; > 1,000,000: 1000003, 1000033, 1000037 +(take 3 (filter #(prime? %) (iterate inc 1000000))) +;=> (1000003 1000033 1000037) + +;=> 1.908832125 + +;; time taken seem to increase as the range increases. +;; but they are totally random on the jvm, so I can't find +;; the exact relation. + +(comment +user> (microbench 10 (take 3 (filter #(prime? %) (iterate inc 1000)))) +Warming up! +Benchmarking... +(1009 1013 1019) +(1009 1013 1019) +(1009 1013 1019) +(1009 1013 1019) +(1009 1013 1019) +(1009 1013 1019) +(1009 1013 1019) +(1009 1013 1019) +(1009 1013 1019) +(1009 1013 1019) +Total runtime: 0.28404500000000005 +Highest time : 0.083949 +Lowest time : 0.019416 +Average : 0.022585000000000008 +(0.083949 0.019416 0.023257 0.020394 0.024165 0.024514 0.024374 0.020813 0.021721 0.021442) +user> (microbench 10 (take 3 (filter #(prime? %) (iterate inc 10000)))) +Warming up! +Benchmarking... +(10007 10009 10037) +(10007 10009 10037) +(10007 10009 10037) +(10007 10009 10037) +(10007 10009 10037) +(10007 10009 10037) +(10007 10009 10037) +(10007 10009 10037) +(10007 10009 10037) +(10007 10009 10037) +Total runtime: 0.26462800000000003 +Highest time : 0.067118 +Lowest time : 0.020533 +Average : 0.022122125000000006 +(0.067118 0.022698 0.024095 0.023537 0.020533 0.020882 0.020603 0.021372 0.020603 0.023187) +user> (microbench 10 (take 3 (filter #(prime? %) (iterate inc 100000)))) +Warming up! +Benchmarking... +(100003 100019 100043) +(100003 100019 100043) +(100003 100019 100043) +(100003 100019 100043) +(100003 100019 100043) +(100003 100019 100043) +(100003 100019 100043) +(100003 100019 100043) +(100003 100019 100043) +(100003 100019 100043) +Total runtime: 0.265118 +Highest time : 0.073263 +Lowest time : 0.020254 +Average : 0.021450125000000004 +(0.073263 0.023048 0.023467 0.021022 0.020394 0.020254 0.021302 0.020812 0.020743 0.020813) +) + +;;; can't make out any sqrt(10) relation between the numbers. may be because +;;; jvm compilation is doing some behind the scene tricks. diff --git a/src/sicp/ex1_23.clj b/src/sicp/ex1_23.clj new file mode 100644 index 0000000..8200ecf --- /dev/null +++ b/src/sicp/ex1_23.clj @@ -0,0 +1,19 @@ +(ns sicp.ex1_23 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;;; exercise 1.23 +(defn next-divisor [n] + (if (= n 2) + 3 + (+ n 2))) + + +(defn find-divisor [n test-divisor] + (cond (> (square test-divisor) n) n + (divides? test-divisor n) test-divisor + :else (find-divisor n (next-divisor test-divisor)))) + +(comment + I can't see any noticable difference in the speed. +) diff --git a/src/sicp/ex1_24.clj b/src/sicp/ex1_24.clj new file mode 100644 index 0000000..ddffc11 --- /dev/null +++ b/src/sicp/ex1_24.clj @@ -0,0 +1,10 @@ +(ns sicp.ex1_24 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;;; exercise 1.24 +(comment + (microbench 10 (take 3 (filter #(fast-prime? %) (iterate inc 1000)))) + ... + "I did not observe any difference". +) diff --git a/src/sicp/ex1_25.clj b/src/sicp/ex1_25.clj new file mode 100644 index 0000000..8dfd0fc --- /dev/null +++ b/src/sicp/ex1_25.clj @@ -0,0 +1,17 @@ +(ns sicp.ex1_25 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; exercise 1.25 +(defn expmod [base exp m] + (rem (fast-expt base exp) m)) + +(comment + In the case of the original expmod implementation, square and remainder + calls are interspersed, so square always deals with a small number, whereas + with the above way, we do a series of squaring and then in the end take + remainder. Squaring of big numbers are very inefficient as the CPU has to + do multi-byte arithmetic which consumes many cycles. + + So the new version is several times slower than the original. +) diff --git a/src/sicp/ex1_26.clj b/src/sicp/ex1_26.clj new file mode 100644 index 0000000..cd1ba73 --- /dev/null +++ b/src/sicp/ex1_26.clj @@ -0,0 +1,12 @@ +(ns sicp.ex1_26 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;;; exercise 1.26 +(comment + "Instead of calling (square x), Louis now makes does (* x x). In the former, + case, x is evaluated only once, where as in the second, x gets evaluated + 2x, 4x, 8x, 16x and so on (for any x which is recursive). So, if the original + computation is considered T(log_n), then the new process T(n). This can also + be illustrated with the call tree." +) diff --git a/src/sicp/ex1_27.clj b/src/sicp/ex1_27.clj new file mode 100644 index 0000000..e0c02e1 --- /dev/null +++ b/src/sicp/ex1_27.clj @@ -0,0 +1,34 @@ +(ns sicp.ex1_27 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; exercise 1.27 +(comment + "Some notes on Carmichael numbers: Carmichael numbers are those that fail + Fermat little test. That is, for any n in the Carmichael set, + (prime? n) => false + (fermat-test n) => true." + ) +(defn brute-force-fermat-test [n] + (try-all 2 n)) + +(defn try-all [a n] + (cond (= a n) true + (try-it a n) (try-all (inc a) n) + :else false)) +(comment + "all the given numbers pass the above test, i.e. for every a < n, + a^n mod n === a mod n" + user> (brute-force-fermat-test 561) + true + user> (brute-force-fermat-test 1105) + true + user> (brute-force-fermat-test 1729) + true + user> (brute-force-fermat-test 2465) + true + user> (brute-force-fermat-test 2821) + true + user> (brute-force-fermat-test 6601) + true + ) diff --git a/src/sicp/ex1_28.clj b/src/sicp/ex1_28.clj new file mode 100644 index 0000000..0a8e1f1 --- /dev/null +++ b/src/sicp/ex1_28.clj @@ -0,0 +1,30 @@ +(ns sicp.ex1_28 + (:use [sicp utils] + [clojure.contrib trace test-is])) + + +;;; exercise 1.28 +(defn expmod2 [base exp m] + (cond (= exp 0) 1 + (even? exp) (square-test (expmod2 base (/ exp 2) m) m) + :else (rem (* base (expmod2 base (dec exp) m)) + m))) + +(defn square-test [x m] + (if (and (not (or (= x 1) (= x (- m 1)))) + (= (rem (square x) m) 1)) + 0 + (rem (square x) m))) + +(defn miller-rabin-test [n] + (try-it (+ 2 (rand-int (- n 2))) + n)) + +(defn try-it [a n] + (= (expmod2 a (- n 1) n) 1)) + +(comment + "If the random number generated (a) is 1, then this returns false + positives. So generate random numbers between 2 and n-1. (is this + assumption correct?) " +) \ No newline at end of file diff --git a/src/sicp/ex1_29.clj b/src/sicp/ex1_29.clj new file mode 100644 index 0000000..33a3458 --- /dev/null +++ b/src/sicp/ex1_29.clj @@ -0,0 +1,28 @@ +(ns sicp.ex1_29 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; simpson's rule of integration +(defn sum [term a next b] + (if (> a b) + 0 + (+ (term a) + (sum term (next a) next b)))) + +(defn make-fac [k n] + (cond (= k 0) 1 + (= k n) 1 + (even? k) 2 + :else 4)) + +(defn simpson-sum [term a next-fn b n k] + (let [fac (make-fac k n)] + (if (> k n) + 0 + (+ (* fac (term a)) + (simpson-sum term (next-fn a) next-fn b n (+ k 1)))))) + +(defn simpson-rule [f a b n] + (let [h (/ (- b a) n)] + (* (simpson-sum f a #(+ h %) b n 0) + (/ h 3.0)))) diff --git a/src/sicp/ex1_3.clj b/src/sicp/ex1_3.clj new file mode 100644 index 0000000..b7e70b2 --- /dev/null +++ b/src/sicp/ex1_3.clj @@ -0,0 +1,25 @@ +(ns sicp.ex1_3 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; 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)))) diff --git a/src/sicp/ex1_4.clj b/src/sicp/ex1_4.clj new file mode 100644 index 0000000..2d8e0bd --- /dev/null +++ b/src/sicp/ex1_4.clj @@ -0,0 +1,15 @@ +(ns sicp.ex1_4 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; 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. + ) diff --git a/src/sicp/ex1_5.clj b/src/sicp/ex1_5.clj new file mode 100644 index 0000000..9638b3b --- /dev/null +++ b/src/sicp/ex1_5.clj @@ -0,0 +1,30 @@ +(ns sicp.ex1_5 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; 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. + ) diff --git a/src/sicp/ex1_6.clj b/src/sicp/ex1_6.clj new file mode 100644 index 0000000..5144f1b --- /dev/null +++ b/src/sicp/ex1_6.clj @@ -0,0 +1,29 @@ +(ns sicp.ex1_6 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; 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.) diff --git a/src/sicp/ex1_7.clj b/src/sicp/ex1_7.clj new file mode 100644 index 0000000..f79dae6 --- /dev/null +++ b/src/sicp/ex1_7.clj @@ -0,0 +1,54 @@ +(ns sicp.ex1_7 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; 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 + ) \ No newline at end of file diff --git a/src/sicp/ex1_8.clj b/src/sicp/ex1_8.clj new file mode 100644 index 0000000..bdf2e05 --- /dev/null +++ b/src/sicp/ex1_8.clj @@ -0,0 +1,30 @@ +(ns sicp.ex1_8 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; exercise 1.8: cube root +(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> +) diff --git a/src/sicp/ex1_9.clj b/src/sicp/ex1_9.clj new file mode 100644 index 0000000..4029985 --- /dev/null +++ b/src/sicp/ex1_9.clj @@ -0,0 +1,48 @@ +(ns sicp.ex1_9 + (:use [sicp utils] + [clojure.contrib trace test-is])) + +;; 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 +;; )