Add Initial solutions

SICP/exercise_1_15.janet

@@ -0,0 +1,41 @@
+(defn cube [x]
+  (* x x x))
+
+(defn p [x]
+  (-
+   (* 3 x)
+   (* 4 (cube x))))
+
+(defn sine [angle]
+  (if (not (> (math/abs angle) 0.1))
+    angle
+    (p (sine (/ angle 3.0)))))
+
+(import ./dot :as dot)
+
+(defn add-to [graph counter angle parent]
+  (def label (string/format "(sine %f)" angle))
+  (def node_name (string/format "node_%d" counter))
+  (def clr
+    (cond (> angle 0.1) "lightgray"
+          "lightgreen"))
+  (dot/add-node graph node_name :label label :shape "box" :fillcolor clr :style "filled")
+
+  (dot/add-relation graph parent node_name)
+  node_name)
+
+(defn sine2 [angle]
+  (def graph (dot/create "angle" :graph_type :digraph))
+  (var counter 0)
+  (defn sin [angle parent]
+    (def name (add-to graph counter angle parent))
+    (set counter (+ counter 1))
+    (if (not (> (math/abs angle) 0.1))
+      angle
+      (p (sin (/ angle 3.0) name))))
+
+  (def result (sin angle "start"))
+  (dot/write graph "exercise_1_15.gv")
+  result)
+
+(print (sine2 12.15))

SICP/exercise_1_16.janet

@@ -0,0 +1,83 @@
+
+(defn expt [b n]
+  (if (= n 0)
+    1
+    (* b (expt b (- n 1)))))
+
+(defn expt2 [b n]
+  (defn expt-iter [b n s]
+    (if (= n 0)
+      s
+      (expt-iter b (- n 1) (* s b))))
+  (expt-iter b n 1))
+
+(defn fast-expt [b n]
+  (defn even? [n]
+    (= (mod n 2) 0))
+  (defn square [n]
+    (* n n))
+  (defn expt-iter [b n s]
+    (cond
+      (= n 0) s
+      (even? n) (square (expt-iter b (/ n 2) s))
+      (* b (expt-iter b (- n 1) s))))
+  (expt-iter b n 1))
+
+(defn fast-expt2 [b n]
+  (defn even? [n]
+    (= (mod n 2) 0))
+  (defn square [n]
+    (* n n))
+  (defn expt-iter [b n s]
+    (cond
+      (= n 0) s
+      (even? n) (expt-iter (square b) (/ n 2) s)
+      (expt-iter b (- n 1) (* b s))))
+  (expt-iter b n 1))
+
+(defn count-fast-expt2 [b n]
+  (var counter 0)
+  (defn even? [n]
+    (= (mod n 2) 0))
+  (defn square [n]
+    (* n n))
+  (defn expt-iter [b n s]
+    (set counter (+ counter 1))
+    (cond
+      (= n 0) s
+      (even? n) (expt-iter (square b) (/ n 2) s)
+      (expt-iter b (- n 1) (* b s))))
+  (expt-iter b n 1)
+  counter)
+
+# case 1 (n mod 2 = 0):
+#   f(b,n) = f(b,n/2)^2
+# case 2 (n mod 2 = 1):
+#   f(b,n) = f(b,n-1)*b
+# iterative approach:
+# case 1 (n mod 2 = 0):
+#   f(b,n) = f(b^2, n/2)
+# case 2 (n mod 2 = 1):
+#   f(b,n) = f(b, n-1)*b
+
+# examples:
+# n = 1
+#   f(b,1) = f(b,0)*b = 1 * b = b
+# n = 2
+#   f(b,2) = f(b^2,1) = 1 * b^2 = b^2
+# n = 3
+#   f(b,3) = f(b,2)*b = f(b^2, 1) * b = b * b^2 = b^3
+# n = 4
+#   f(b,4) = f(b^2,2) = f(b^4, 1) = 1 * b^4 = b^4
+# n = 5
+#   f(b,5) = f(b,4)*b = f(b^4, 1) = b * b^5 = b^5
+
+(def k 100000)
+(defn lo [n]
+  (cond
+    (= n k) (printf "%d,%d" n (count-fast-expt2 0.99 n))
+    (do
+      (printf "%d,%d" n (count-fast-expt2 0.99 n))
+      (lo (+ n 1)))))
+
+(lo 0)

SICP/exercise_1_17.janet

@@ -0,0 +1,48 @@
+(defn mul [a b]
+  (if (= b 0)
+    0
+    (+ a (mul a (- b 1)))))
+
+(defn fast-mul [a b]
+  (defn even? [n]
+    (= (mod n 2) 0))
+  (defn double [n]
+    (* n 2))
+  (defn halve [n]
+    (/ n 2))
+  (defn mul-iter [a b]
+    (cond
+      (= b 0) 0
+      (= b 1) a
+      (even? b) (double (mul-iter a (halve b)))
+      (+ a (mul-iter a (- b 1)))))
+  (mul-iter a b))
+
+# Similar to exercise 1.16 the procedure is again split into two cases:
+# case 1: b even?
+#   f(a,b) = f(2a,b/2)
+# case 2: b uneven?
+#   f(a,b) = a+f(a,b-1)
+# given:
+#   f(a,0) = 0
+#   f(a,1) = a
+#   f(a,2) = 2a
+#   f(a,n) = na
+# prove (for n > 1):
+#   f(a, 2*n) = f(2a, n)
+#   f(a, 2*n-1) = a + f(a,2*n-2)
+# solution:
+#   2*n*a = 2*a*n
+#   (2*n - 1) * a = a + (2*n - 2)*a
+#   2*n*a - a = a + 2*n*a - 2a
+#   2*n*a - a = 2*n*a - a
+
+(def k 100)
+(defn lo [n]
+  (cond
+    (= n k) (printf "%d %f" n (fast-mul 10 n))
+    (do
+      (printf "%d %f" n (fast-mul 10 n))
+      (lo (+ n 1)))))
+
+(lo 0)

SICP/exercise_1_18.janet

@@ -0,0 +1,82 @@
+(defn mul [a b]
+  (if (= b 0)
+    0
+    (+ a (mul a (- b 1)))))
+
+(defn fast-mul [a b]
+  (defn even? [n]
+    (= (mod n 2) 0))
+  (defn double [n]
+    (* n 2))
+  (defn halve [n]
+    (/ n 2))
+  (defn mul-iter [a b s]
+    (cond
+      (= b 0) s
+      (even? b) (mul-iter (double a) (halve b) s)
+      (mul-iter a (- b 1) (+ a s))))
+  (mul-iter a b 0))
+
+(defn fast-mul2 [a b]
+  (defn even? [n]
+    (= (mod n 2) 0))
+  (defn double [n]
+    (* n 2))
+  (defn halve [n]
+    (/ n 2))
+  (defn mul-iter [a b s]
+    (cond
+      (= b 0) s
+      (= a 0) s
+      (even? b) (mul-iter (double a) (halve b) s)
+      (mul-iter (double a) (halve (- b 1)) (+ s a))))
+  (mul-iter a b 0))
+
+# Similar to exercise 1.16 the procedure is again split into two cases:
+# case 1: b even?
+#   f(a,b) = f(2a,b/2)
+# case 2: b uneven?
+#   f(a,b) = a+f(a,b-1)
+# given:
+#   f(a,0) = 0
+#   f(a,1) = a
+#   f(a,2) = 2a
+#   f(a,n) = na
+# prove (for n > 1):
+#   f(a, 2*n) = f(2a, n)
+#   f(a, 2*n-1) = a + f(a,2*n-2)
+# solution:
+#   2*n*a = 2*a*n
+#   (2*n - 1) * a = a + (2*n - 2)*a
+#   2*n*a - a = a + 2*n*a - 2a
+#   2*n*a - a = 2*n*a - a
+
+(def k 100)
+(defn lo [n]
+  (cond
+    (= n k) (printf "%d %f" n (fast-mul 10 n))
+    (do
+      (printf "%d %f" n (fast-mul 10 n))
+      (lo (+ n 1)))))
+
+(lo 0)
+
+(def k 100)
+(defn lo2 [n]
+  (cond
+    (= n k) (printf "%d %f" n (fast-mul2 10 n))
+    (do
+      (printf "%d %f" n (fast-mul2 10 n))
+      (lo2 (+ n 1)))))
+
+(lo2 0)
+
+(def k 100)
+(defn lo3 [n]
+  (cond
+    (= n k) (printf "%d %f" n (fast-mul2 n 10))
+    (do
+      (printf "%d %f" n (fast-mul2 n 10))
+      (lo3 (+ n 1)))))
+
+(lo3 0)

SICP/exercise_1_19.janet

@@ -0,0 +1,64 @@
+(defn fib [n]
+  (defn fib-iter [n a b]
+    (cond
+      (= n 0) b
+      (fib-iter (- n 1) (+ a b) a)))
+  (fib-iter n 1 0))
+
+(defn fib-fast [n]
+  (defn even? [n]
+    (= (mod n 2) 0))
+  (defn square [n]
+    (* n n))
+  (defn fib-iter [a b p q n]
+    (cond
+      (= n 0) b
+      (even? n)
+        (fib-iter
+          a b
+          (+ (square p) (square q))
+          (+ (* 2 p q) (square q))
+          (/ n 2))
+      (fib-iter
+        (+ (* b q) (* a q) (* a p))
+        (+ (* b p) (* a q))
+        p q (- n 1))))
+  (fib-iter 1 0 0 1 n))
+
+(defn count-fib [n]
+  (var c 0)
+  (defn fib-iter [n a b]
+    (set c (+ c 1))
+    (cond
+      (= n 0) b
+      (fib-iter (- n 1) (+ a b) a)))
+  (fib-iter n 1 0)
+  c)
+
+(defn count-fib-fast [n]
+  (defn even? [n]
+    (= (mod n 2) 0))
+  (defn square [n]
+    (* n n))
+  (var c 0)
+  (defn fib-iter [a b p q n]
+    (set c (+ 1 c))
+    (cond
+      (= n 0) b
+      (even? n)
+        (fib-iter
+          a b
+          (+ (square p) (square q))
+          (+ (* 2 p q) (square q))
+          (/ n 2))
+      (fib-iter
+        (+ (* b q) (* a q) (* a p))
+        (+ (* b p) (* a q))
+        p q (- n 1))))
+  (fib-iter 1 0 0 1 n)
+  c)
+
+(var k 0)
+(while (< k 100000)
+  (printf "%d,%d,%d" (+ k 1) (count-fib k) (count-fib-fast k))
+  (set k (+ k 1)))

SICP/exercise_1_21.janet

@@ -0,0 +1,15 @@
+(defn smallest-divisor [n]
+  (defn square [n]
+    (* n n))
+  (defn divides? [a b]
+    (= (mod b a) 0))
+  (defn iter [n test]
+    (cond
+      (> (square test) n) n
+      (divides? test n) test
+      (iter n (+ test 1))))
+  (iter n 2))
+
+(trace (smallest-divisor 199))
+(print (smallest-divisor 1999))
+(print (smallest-divisor 19999))

SICP/exercise_1_22.janet

@@ -0,0 +1,43 @@
+(defn square [n]
+  (* n n))
+
+(defn divides? [a b]
+  (= (mod b a) 0))
+
+(defn smallest-divisor [n]
+  (defn iter [n test]
+    (cond
+      (> (square test) n) n
+      (divides? test n) test
+      (iter n (+ test 1))))
+  (iter n 2))
+
+(defn prime? [n]
+  (= n (smallest-divisor n)))
+
+(defn search-for-primes [start count]
+  (defn report-time [n elapsed-time]
+    (printf "%d *** %fus" n (* elapsed-time 1000000.0)))
+  (defn start-prime-test [n start-time]
+    (if (prime? n)
+      (do
+        (report-time n (- (os/clock :cputime) start-time))
+        true)
+      false))
+  (defn times-prime-test [n]
+    (start-prime-test n (os/clock :cputime)))
+  (defn iter [test n]
+    (cond
+      (= n 0) 0
+      (times-prime-test test) (iter (+ test 2) (- n 1))
+      (iter (+ test 2) n)))
+  (cond
+    (= 0 (mod start 2)) (iter (+ start 1) count)
+    (iter start count)))
+
+(search-for-primes 1000 3)
+(search-for-primes 10000 3)
+(search-for-primes 100000 3)
+(search-for-primes 1000000 3)
+(search-for-primes 10000000 3)
+(search-for-primes 100000000 3)

SICP/exercise_1_23.janet

@@ -0,0 +1,62 @@
+(defn square [n]
+  (* n n))
+
+(defn divides? [a b]
+  (= (mod b a) 0))
+
+(defn next [n]
+  (cond
+    (= n 2) 3
+    (+ n 2)))
+
+(defn smallest-divisor [n]
+  (defn iter [n test]
+    (cond
+      (> (square test) n) n
+      (divides? test n) test
+      (iter n (+ test 1))))
+  (iter n 2))
+
+(defn prime? [n]
+  (= n (smallest-divisor n)))
+
+(defn smallest-divisor2 [n]
+  (defn iter [n test]
+    (cond
+      (> (square test) n) n
+      (divides? test n) test
+      (iter n (next test))))
+  (iter n 2))
+
+(defn prime2? [n]
+  (= n (smallest-divisor2 n)))
+
+(defn search-for-primes [start count]
+  (defn report-time [n elapsed-time1 elapsed-time2]
+    (printf "%d,%f,%f" n (* elapsed-time1 1000000.0) (* elapsed-time2 1000000.0)))
+  (defn start-prime-test [n start-time]
+    (def a (prime? n))
+    (def end-time-1 (os/clock :cputime))
+    (def elapsed (- end-time-1 start-time))
+    (def b (prime2? n))
+    (def elapsed2 (- (os/clock :cputime) end-time-1))
+    (if (and a b)
+      (do
+        (report-time n elapsed elapsed2)
+        true)
+      false))
+  (defn times-prime-test [n]
+    (start-prime-test n (os/clock :cputime)))
+  (defn iter [test n]
+    (cond
+      (= n 0) 0
+      (times-prime-test test) (iter (+ test 2) (- n 1))
+      (iter (+ test 2) n)))
+  (cond
+    (= 0 (mod start 2)) (iter (+ start 1) count)
+    (iter start count)))
+
+(search-for-primes 1000 100000)
+#(search-for-primes 10000 3)
+#(search-for-primes 100000 3)
+#(search-for-primes 1000000 3)

SICP/exercise_1_24.janet

@@ -0,0 +1,61 @@
+(defn random [n]
+  (math/floor (* n (math/random))))
+
+(defn square [n]
+  (* n n))
+
+(defn divides? [a b]
+  (= (mod b a) 0))
+
+(defn expmod [base exp m]
+  (cond
+    (= exp 0) 1
+    (even? exp) (mod (square (expmod base (/ exp 2) m)) m)
+    (mod (* base (expmod base (- exp 1) m)) m)))
+
+(defn fast-expt [b n]
+  (defn expt-iter [b n s]
+    (cond
+      (= n 0) s
+      (even? n) (square (expt-iter b (/ n 2) s))
+      (* b (expt-iter b (- n 1) s))))
+  (expt-iter b n 1))
+
+(defn expmod-n [base exp m]
+  (mod (fast-expt base exp) m))
+
+(print (expmod 10 11 11))
+(print (expmod-n 10 11 11))
+
+(defn fermat-test [n]
+  (defn try-it [a]
+    (= (expmod a n n) a))
+  (try-it (+ 1 (random (- n 1)))))
+
+(defn fast-prime? [n times]
+  (cond
+    (= times 0) true
+    (fermat-test n) (fast-prime? n (- times 1))
+    false))
+
+(defn search-for-primes [start count]
+  (defn report-time [n elapsed-time]
+    (printf "%d,%f" n (* elapsed-time 1000000.0)))
+  (defn start-prime-test [n start-time]
+    (if (fast-prime? n 7)
+      (do
+        (report-time n (- (os/clock :cputime) start-time))
+        true)
+      false))
+  (defn times-prime-test [n]
+    (start-prime-test n (os/clock :cputime)))
+  (defn iter [test n]
+    (cond
+      (= n 0) 0
+      (times-prime-test test) (iter (+ test 2) (- n 1))
+      (iter (+ test 2) n)))
+  (cond
+    (= 0 (mod start 2)) (iter (+ start 1) count)
+    (iter start count)))
+
+#(search-for-primes 1000 1000000)

SICP/exercise_1_26.janet

@@ -0,0 +1,29 @@
+(defn random [n]
+  (math/floor (* n (math/random))))
+
+(defn square [n]
+  (* n n))
+
+(defn divides? [a b]
+  (= (mod b a) 0))
+
+(defn expmod [base exp m]
+  (cond
+    (= exp 0) 1
+    (even? exp) (mod (square (expmod base (/ exp 2) m)) m)
+    (mod (* base (expmod base (- exp 1) m)) m)))
+
+(defn fermat-test [n]
+  (defn iter [a]
+    (cond
+      (= a 0) true
+      (= (expmod a n n) a) (iter (- a 1))
+      false))
+  (iter (- n 1)))
+
+(print (fermat-test 561))
+(print (fermat-test 1105))
+(print (fermat-test 1729))
+(print (fermat-test 2465))
+(print (fermat-test 2821))
+(print (fermat-test 6601))

SICP/exercise_1_28.janet

@@ -0,0 +1,48 @@
+(defn square [n]
+  (* n n))
+
+(defn even? [n]
+  (= (mod n 2) 0))
+
+(defn expmod [base exp m]
+  (defn squaring-test [k]
+    (cond
+      (and
+        (not (= k 1))
+        (not (= k (- m 1)))
+        (= (mod (square k) m) 1)) 0
+      (mod (square k) m)))
+  (cond
+    (= exp 0) 1
+    (even? exp) (squaring-test (expmod base (/ exp 2) m))
+    (mod (* base (expmod base (- exp 1) m)) m)))
+
+(defn miller-rabin-test [n]
+  (defn random [n]
+    (math/floor (* (math/random) n)))
+  (defn try-it [a]
+    (def test (expmod a (- n 1) n))
+    (cond
+      (= test 0) false
+      true))
+  (try-it (+ 1 (random (- n 1)))))
+
+(defn prime? [n times]
+  (cond
+    (= times 0) true
+    (miller-rabin-test n) (prime? n (- times 1))
+    false))
+
+
+(print "Should be true")
+(print (prime? 11 100))
+(print (prime? 13 100))
+(print (prime? 5 100))
+
+(print "Should be false")
+(print (prime? 561 100))
+(print (prime? 1105 100))
+(print (prime? 1729 100))
+(print (prime? 2465 100))
+(print (prime? 2821 100))
+(print (prime? 6601 100))

SICP/exercise_1_29.janet

@@ -0,0 +1,44 @@
+(defn cube [n]
+  (+ (* 5 n n n) (math/sin (* 2.5 n))))
+
+(defn sum [term next a b]
+  (if (> a b)
+    0
+    (+ (term a)
+       (sum term next (next a) b))))
+
+(defn integral-old [f a b dx]
+  (defn add-dx [x]
+    (+ x dx))
+  (* (sum f add-dx (+ a (/ dx 2.0)) b) dx))
+
+(defn integral [f a b n]
+  (def h (/ (- b a) n))
+  (defn incre [n]
+    (+ n 1))
+  (defn apply [k]
+    (def multiplier
+      (cond
+        (or (= k 0) (= k n)) 1
+        (= (mod k 2) 0) 2
+        4))
+    (* multiplier (f (+ a (* k h)))))
+  (* (/ h 3) (sum apply incre 0 n)))
+
+(defn integral-improved [f a b n]
+  (def h (/ (- b a) n))
+  (defn incre [k]
+    (+ k 2))
+  (defn apply [k]
+    (f (+ a (* k h))))
+  (* (/ h 3)
+     (+
+      (f a)
+      (* 4 (sum apply incre 1 (- n 1)))
+      (* 2 (sum apply incre 2 (- n 1)))
+      (f b))))
+
+(printf "%.23f" (integral-improved cube 0 1 10))
+(printf "%.23f" (integral-improved cube 0 1 100))
+(printf "%.23f" (integral-improved cube 0 1 1000))
+(printf "%.23f" (integral-improved cube 0 1 10000))

SICP/exercise_1_30.janet

@@ -0,0 +1,49 @@
+(defn sum-recur [term next a b]
+  (if (> a b)
+    0
+    (+ (term a)
+       (sum-recur term next (next a) b))))
+
+(defn sum-iter [term next a b]
+  (defn iter [a result]
+    (if (> a b)
+      result
+      (iter (next a) (+ result (term a)))))
+  (iter a 0))
+
+(defn cube [n]
+  (* n n n))
+(defn inc [n]
+  (+ n 1))
+
+(defn simpsons-recur [f a b n]
+  (def h (/ (- b a) n))
+  (defn fapply [k]
+    (f (+ a (* k h))))
+  (defn add-two [k]
+    (+ k 2))
+  (* (/ h 3)
+     (+
+      (f a)
+      (f b)
+      (* 4 (sum-recur fapply add-two 1 n))
+      (* 2 (sum-recur fapply add-two 2 (- n 1))))))
+
+(defn simpsons-iter [f a b n]
+  (def h (/ (- b a) n))
+  (defn fapply [k]
+    (f (+ a (* k h))))
+  (defn add-two [k]
+    (+ k 2))
+  (* (/ h 3)
+     (+
+      (f a)
+      (f b)
+      (* 4 (sum-iter fapply add-two 1 n))
+      (* 2 (sum-iter fapply add-two 2 (- n 1))))))
+
+(print (sum-recur cube inc 1 10))
+(print (sum-iter cube inc 1 10))
+
+(print (simpsons-recur cube 0 1 100))
+(print (simpsons-iter cube 0 1 100))

SICP/exercise_1_31.janet

@@ -0,0 +1,46 @@
+(defn product-iter [term next a b]
+  (defn iter [a result]
+    (if (> a b)
+      result
+      (iter (next a) (* result (term a)))))
+  (iter a 1))
+
+(defn product-recur [term next a b]
+  (if (> a b)
+    1
+    (* (term a)
+       (product-recur term next (next a) b))))
+
+(defn identity [n] n)
+(defn inc [n] (+ n 1))
+
+(defn factorial-iter [a b]
+  (product-iter identity inc a b))
+
+(defn factorial-recur [a b]
+  (product-recur identity inc a b))
+
+(defn pi [n]
+  (defn next [k]
+    (+ k 1))
+  (defn even-term [k]
+    (cond
+      (= (mod k 2) 0) (+ 2 k)
+      (+ 2 (- k 1))))
+  (defn odd-term [k]
+    (cond
+      (= (mod k 2) 0) (+ 3 k)
+      (+ 3 (- k 1))))
+  (* 4
+     (/
+      (product-iter even-term next 1 n)
+      (product-iter odd-term next 0 (- n 1)))))
+
+(var x 1)
+(while (< x 20)
+  (print (factorial-iter 1 x))
+  (print (factorial-recur 1 x))
+  (print "")
+  (print (pi x))
+  (print "")
+  (set x (+ x 1)))

SICP/exercise_1_32.janet

@@ -0,0 +1,32 @@
+(defn accumulate-iter [comb null-val term next a b]
+  (defn iter [a result]
+    (if (> a b)
+      result
+      (iter (next a) (comb (term a) result))))
+  (iter a null-val))
+
+(defn accumulate-recur [comb null-val term next a b]
+  (if (> a b)
+    null-val
+    (comb (term a)
+          (accumulate-recur comb null-val term next (next a) b))))
+
+(defn add [a b]
+  (+ a b))
+
+(defn mult [a b]
+  (* a b))
+
+(defn id [n] n)
+(defn inc [n] (+ n 1))
+
+(defn sum [a b]
+  (accumulate-recur add 0 id inc a b))
+
+(defn factorial [a b]
+  (accumulate-recur mult 1 id inc a b))
+
+(var x 1)
+(while (< x 10)
+  (printf "n=%d, sum 1-n: %d, factorial 1-n: %d" x (sum 1 x) (factorial 1 x))
+  (set x (+ x 1)))

SICP/exercise_1_33.janet

@@ -0,0 +1,64 @@
+(defn filtered-accumulate [predicate comb null-val term next a b]
+  (defn iter [a result]
+    (if (> a b)
+      result
+      (iter (next a) (cond
+                       (predicate a b) (comb (term a) result)
+                       result))))
+  (iter a null-val))
+
+(defn prime? [n x]
+  (defn random [k]
+    (math/floor (* (math/random) k)))
+  (defn square [k]
+    (* k k))
+  (defn even? [k]
+    (= (mod k 2) 0))
+  (defn expmod [base exp m]
+    (defn squaring-test [k]
+      (cond
+        (and
+          (not (= k 1))
+          (not (= k (- m 1)))
+          (= (mod (square k) m) 1)) 0
+        (mod (square k) m)))
+    (cond
+      (= exp 0) 1
+      (even? exp) (squaring-test (expmod base (/ exp 2) m))
+      (mod (* base (expmod base (- exp 1) m)) m)))
+  (defn miller-rabin-test [k]
+    (defn try-it [a]
+      (cond
+        (= (expmod a (- k 1) k) 0) false
+        true))
+    (try-it (+ 1 (random (- k 1)))))
+  (defn iter [k times]
+    (cond
+      (= times 0) true
+      (miller-rabin-test k) (iter k (- times 1))
+      false))
+  (iter n 100))
+
+(defn rel-prime? [a b]
+  (defn gcd [x y]
+    (if (= y 0)
+      x
+      (gcd y (mod x y))))
+  (cond
+    (= (gcd a b) 1) true
+    false))
+
+(defn prime-sum [a b]
+  (defn identity [n] n)
+  (defn next [n] (+ n 1))
+  (defn add [a b] (+ a b))
+  (filtered-accumulate prime? add 0 identity next a b))
+
+(defn rel-prime-sum [n]
+  (defn identity [n] n)
+  (defn next [n] (+ n 1))
+  (defn mul [a b] (* a b))
+  (filtered-accumulate rel-prime? mul 1 identity next 1 n))
+
+(print (prime-sum 2 5))
+(print (rel-prime-sum 6))

SICP/exercise_1_34.janet

@@ -0,0 +1,8 @@
+(defn f [g] (g 2))
+
+(defn square [n]
+  (* n n))
+
+(print (f square))
+(print (f (fn [z] (* z (+ z 1)))))
+(print (f f))

SICP/exercise_1_35.janet

@@ -0,0 +1,13 @@
+(def tolerance 0.00001)
+(defn fixed-point [f first-guess]
+  (defn close-enough? [v1 v2]
+    (< (math/abs (- v1 v2))
+       tolerance))
+  (defn try-it [guess]
+    (let [next (* 0.5 (+ guess (f guess)))]
+      (if (close-enough? guess next)
+        next
+        (try-it next))))
+  (try-it first-guess))
+
+(print (fixed-point (fn [x] (+ 1 (/ 1 x))) 1.0))

SICP/exercise_1_36.janet

@@ -0,0 +1,28 @@
+(def tolerance 0.00001)
+
+(defn fixed-point [f damping first-guess]
+  (defn close-enough? [v1 v2]
+    (< (math/abs (- v1 v2))
+       tolerance))
+  (defn try-it [guess]
+    (printf "current guess %f" guess)
+    (let [next (damping guess (f guess))]
+      (if (close-enough? guess next)
+        next
+        (try-it next))))
+  (try-it first-guess))
+
+(print "undamped")
+(print (fixed-point 
+         (fn [x] (/ (math/log 1000) (math/log x)))
+         (fn [x1 x2] x2) 
+         2.0
+       )
+)
+(print "damped")
+(print (fixed-point
+         (fn [x] (/ (math/log 1000) (math/log x)))
+         (fn [x1 x2] (* 0.5 (+ x1 x2)))
+         2.0
+        )
+)

SICP/exercise_1_37.janet

@@ -0,0 +1,23 @@
+(defn cont-frac [N D k]
+  (defn iter [i]
+    (cond
+      (= k i) (/ (N i) (D i))
+      (/ (N i) (+ (D i) (iter (+ i 1))))))
+  (iter 1))
+
+(defn cont-frac-iter [N D k]
+  (defn iter [prev i]
+    (if (>= i k)
+      prev
+      (cond
+        (= i 1) (iter (/ (N (- k i)) (D (- k i))) (+ i 1))
+        (iter (/ (N (- k i)) (+ (D (- k i)) prev)) (+ i 1)))))
+  (iter 0 1))
+
+(print (cont-frac (fn [i] 1.0)
+                  (fn [i] 1.0)
+                  12))
+
+(print (cont-frac-iter (fn [i] 1.0)
+                  (fn [i] 1.0)
+                  12))

SICP/exercise_1_38.janet

@@ -0,0 +1,17 @@
+(defn cont-frac [N D k]
+  (defn iter [prev i]
+    (if (>= i k)
+      prev
+      (cond
+        (= i 1) (iter (/ (N (- k i)) (D (- k i))) (+ i 1))
+        (iter (/ (N (- k i)) (+ (D (- k i)) prev)) (+ i 1)))))
+  (iter 0 1))
+
+(defn identity [i] 1.0)
+(defn D [i]
+  (let [n (+ i 1)]
+   (cond
+    (= (mod n 3) 0) (* (/ n 3) 2)
+    1.0)))
+
+(print (+ 2 (cont-frac identity D 100)))

SICP/exercise_1_39.janet

@@ -0,0 +1,18 @@
+(defn cont-frac [N D k]
+  (defn iter [prev i]
+    (if (>= i k)
+      prev
+      (cond
+        (= i 1) (iter (/ (N (- k i)) (D (- k i))) (+ i 1))
+        (iter (/ (N (- k i)) (- (D (- k i)) prev)) (+ i 1)))))
+  (iter 0 1))
+
+(defn tan-cf [x k]
+  (defn odd [i] (- (* i 2) 1))
+  (defn N [i]
+    (cond
+      (= i 1) x
+      (* x x)))
+  (cont-frac N odd k))
+
+(print (tan-cf 1 100))