up to exercise 1.8

Author: kleungkw

kenric/ex.1.1.rkt

@@ -0,0 +1,25 @@
+#lang racket
+
+10 ;10
+(+ 5 3 4) ;12
+(- 9 1) ;8
+(/ 6 2) ;3
+(+ (* 2 4) (- 4 6)) ;6
+(define a 3) ;
+(define b (+ a 1)) ;
+(+ a b (* a b)) ;19
+(= a b) ;#f
+(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

kenric/ex.1.2.rkt

@@ -0,0 +1,5 @@
+#lang racket
+
+(/ (+ 5 4 (- 2
+             (- 3 (+ 6 (/ 4 5)))))
+   (* 3 (- 6 2) (- 2 7)))

kenric/ex.1.3.rkt

@@ -0,0 +1,8 @@
+#lang racket
+
+(define (f n1 n2 n3)
+  (cond [(and (< n1 n2) (< n1 n3))
+         (+ (* n2 n2) (* n3 n3))]
+        [(and (< n2 n1) (< n2 n3))
+         (+ (* n1 n1) (* n3 n3))]
+        [else (+ (* n1 n1) (* n2 n2))]))

kenric/ex.1.4.rkt

@@ -0,0 +1,4 @@
+#lang racket
+
+(define (a-plus-abs-b a b)
+  ((if (> b 0) + -) a b))

kenric/ex.1.5.rkt

@@ -0,0 +1,13 @@
+#lang racket
+
+(define (p) (p))
+(define (test x y)
+  (if (= x 0) 0 y))
+
+(test 0 (p))
+
+; applicative order
+; will be infinite loop, because p will be evaluated first
+
+; normal order
+; will evaluate to 0, because p will be passed in without evaluation, using the substitution model

kenric/ex.1.7.rkt

@@ -0,0 +1,26 @@
+#lang racket
+
+(define (square x)
+  (* x x))
+
+(define (improve guess x)
+  (average guess (/ x guess)))
+
+(define (average x y)
+  (/ (+ x y) 2))
+
+(define (good-enough? guess x)
+  (< (abs (- (square guess) x)) (* x 0.001)))
+
+(define (sqrt-iter guess x)
+  (if (good-enough? guess x)
+      guess
+      (sqrt-iter (improve guess x) x)))
+
+; For very small numbers, the difference between the square of the guess compared
+; to the radicand would easily be under the threshold of 0.001.  This is because
+; square of numbers less than one would yield a smaller output compared to input
+
+; For very large numbers, a large number of iterations needed to get below the hard coded
+; threshold, and machine doesn't have enough precision to work out small differences
+; between large numbers

kenric/ex.1.8.rkt

@@ -0,0 +1,15 @@
+#lang racket
+
+(define (cube x)
+  (* x x x))
+
+(define (improve guess x)
+  (/ (+ (/ x (* guess guess)) (* 2 guess)) 3))
+
+(define (good-enough? guess x)
+  (< (abs (- (cube guess) x)) (* x 0.001)))
+
+(define (cube-iter guess x)
+  (if (good-enough? guess x)
+      guess
+      (cube-iter (improve guess x) x)))