SICP in Clojure: Chapter 1, Exercise 7

This is my Clojure solution to Chapter 1, Exercise 7:

(ns sicp.ch1.ex07
  (:require [sicp.ch1.ex06 :as sicp-ch1-ex06]))

(double (sicp-ch1-ex06/sqrt-iter 1 0.0001)) ; => 0.032... -- should
                                        ; be 0.01

(double (sicp-ch1-ex06/sqrt-iter 1 0.00001)) ; => 0.031... -- should
                                        ; be 0.0031...

(double (sicp-ch1-ex06/sqrt-iter 1 1000000)) ; => 1000 -- good

(defn good-enough?
  [guess prev-guess]
  (< (/ (Math/abs (double (- guess prev-guess))) guess) 0.001))

(defn sqrt-iter
  ([guess x]
   (sqrt-iter guess (inc guess) x))
  ([guess prev-guess x]
   (if (good-enough? guess prev-guess)
     guess
     (sqrt-iter (sicp-ch1-ex06/improve guess x)
                guess
                x))))

(double (sqrt-iter 1 0.0001)) ; => 0.01... -- good

(double (sqrt-iter 1 0.00001)) ; => 0.0031... -- better

(double (sqrt-iter 1 1000000)) ; => 1000 -- still good

SICP in Clojure: Chapter 1, Exercise 6

This is my Clojure solution to Chapter 1, Exercise 6:

(ns sicp.ch1.ex06)

(defn good-enough?
  [guess x]
  (< (Math/abs (- (Math/pow guess 2) x)) 0.001))

(defn average
  [x y]
  (/ (+ x y) 2))

(defn improve
  [guess x]
  (average guess (/ x guess)))

(defn sqrt-iter
  [guess x]
  (if (good-enough? guess x)
    guess
    (sqrt-iter (improve guess x)
               x)))

(double (sqrt-iter 1 2)) ; => 1.41421568627451

(defn new-if
  [predicate then-clause else-clause]
  (cond predicate then-clause
        :else else-clause))

(new-if (= 2 3) 0 5) ; => 5

(new-if (= 1 1) 0 5) ; => 0

(defn new-sqrt-iter
  [guess x]
  (new-if (good-enough? guess x)
          guess
          (new-sqrt-iter (improve guess x)
                         x)))

(new-sqrt-iter 1 2) ; => infinite loop

SICP in Clojure: Chapter 1, Exercise 5

This is my Clojure solution to Chapter 1, Exercise 5:

(ns sicp.ch1.ex05)

(defn p
  []
  (p))

(defn test-order
  [x y]
  (if (zero? x)
    0
    y))

(test-order 6 (p)) ; => applicative order

SICP in Clojure: Chapter 1, Exercise 4

Expressions are either primitive or compound. Procedures are either primitive or compound. A combination is an expression of the form (operator operands ...). This is my Clojure solution to Chapter 1, Exercise 4:

(ns sicp.ch1.ex04)

(defn a-plus-abs-b
  [a b]
  ((if (pos? b) + -) a b))

(a-plus-abs-b 5 -10) ; => 15

(a-plus-abs-b 5 10) ; => 15