SICP/exercise_1_14.janet

@@ -102,11 +102,11 @@
         (cc amount (- kind-of-coins 1) name)
         (cc (- amount (first-denomination kind-of-coins)) kind-of-coins name))))
 
-  (def result (cc amount denom "start"))
+  (def result (cc amount denom "test"))
   (dot/write graph "exercise_1_14.gv")
   result)
 
-(print (count-change2 51 5))
+(print (count-change2 11 2))
 
 # Using the graph we can find the following relation for (cc n 1)
 # f(0,1) = 1

SICP/exercise_1_15.janet

@@ -1,41 +0,0 @@
-(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

@@ -1,83 +0,0 @@
-
-(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

@@ -1,48 +0,0 @@
-(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

@@ -1,82 +0,0 @@
-(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

@@ -1,64 +0,0 @@
-(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

@@ -1,15 +0,0 @@
-(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

@@ -1,43 +0,0 @@
-(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

@@ -1,62 +0,0 @@
-(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

@@ -1,61 +0,0 @@
-(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

@@ -1,29 +0,0 @@
-(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

@@ -1,48 +0,0 @@
-(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

@@ -1,44 +0,0 @@
-(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

@@ -1,49 +0,0 @@
-(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

@@ -1,46 +0,0 @@
-(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

@@ -1,32 +0,0 @@
-(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

@@ -1,64 +0,0 @@
-(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

@@ -1,8 +0,0 @@
-(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

@@ -1,13 +0,0 @@
-(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

@@ -1,28 +0,0 @@
-(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

@@ -1,23 +0,0 @@
-(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

@@ -1,17 +0,0 @@
-(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

@@ -1,18 +0,0 @@
-(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))