finish 1.1

1/1/jord/example.org

@@ -0,0 +1,34 @@
+* 1.1.7 Square Roots by Newton's Method
+
+#+BEGIN_SRC scheme :session sqrt :noweb yes
+
+  (define (sqrt-iter guess x)
+    (if (good-enough? guess x)
+	guess
+	(sqrt-iter (improve guess x)
+		   x)))
+  (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)) 0.001))
+  (define (sqrt x)
+    (sqrt-iter 1.0 x))
+  (sqrt 25)
+
+#+END_SRC
+
+#+RESULTS:
+: 5.000023178253949
+
+#+BEGIN_SRC scheme :session sqrt
+
+  (square (sqrt 1000))
+
+#+END_SRC
+
+#+RESULTS:
+: 1000.000369924366

1/1/jord/exercises.org

@@ -0,0 +1,157 @@
+* 1.1
+
+=> 10
+10
+
+=> (+ 5 3 4)
+12
+
+=> (+ (* 2 4) (- 4 6))
+6
+
+* 1.2
+
+notate the equation referenced in book
+
+#+BEGIN_SRC scheme
+
+  (/ (+ 4
+	5
+	(- 2
+	   (- 3
+	      (+ 6
+		 (/ 4 5)))))
+     (* 3
+	(- 6 2)
+	(- 2 7)))
+
+#+END_SRC
+
+#+RESULTS:
+: -37/150
+
+* 1.3
+
+write a procedure to calculate the sum of the squares of the two
+largest numbers among three
+
+#+BEGIN_SRC scheme
+
+  (define (square x)
+    (* x x))
+
+  (define (bigger x y)
+    (if (> x y) x y))
+
+  (define (biggest x y z)
+    (bigger (bigger x y)
+	    (bigger y z)))
+
+  (define (middle? a x y)
+    (or (and (> a x) (< a y))
+	(and (< a x) (> a y))))
+
+  (define (middle x y z)
+    (cond ((middle? x y z) x)
+	  ((middle? y x z) y)
+	  ((middle? z x y) z)))
+
+  (define (big-squares a b c)
+    (+ (square (biggest a b c))
+       (square (middle a b c))))
+
+  (big-squares 5 9 2)
+
+#+END_SRC
+
+#+RESULTS:
+: 106
+
+* 1.4
+
+#+BEGIN_SRC scheme
+  (define (a-plus-abs-b a b)
+     ((if (> b 0) + -) a b))
+#+END_SRC
+
+combine a and b, using + as the operator if b is positive
+                   use - as the operator if b is negative
+
+* 1.5
+
+#+BEGIN_SRC scheme
+
+  (define (p) (p))
+
+  (define (test x y)p
+    (if (= x 0)
+        0
+	y))
+
+  (test 0 (p))
+
+#+END_SRC
+
+#+RESULTS:
+
+applicative order: decides predicate (= x 0), returning 0
+
+normal order: tries to infinitely expand (p)
+
+im not firm (a litte shaky) on my understanding of this
+
+* 1.6
+
+#+BEGIN_SRC scheme
+
+  (define (new-if predicate then-clause else-clause)
+    (cond (predicate then-clause)
+	  (else else-clause)))
+  (new-if (= 2 3) 0 5)
+  (new-if (= 1 1) 0 5)
+
+  (define (sqrt-iter guess x)
+    (new-if (good-enough? guess x)
+	    guess
+	    (sqrt-iter (improve guess x)
+		       x)))
+
+  (define (sqrt x)
+    (sqrt-iter 1.0 x))
+
+  (sqrt 2) ;; too much recursion
+
+#+END_SRC
+
+I do not have an explanation for why this is :/
+
+* 1.8
+
+Create a similar guessing method using Newton's method for cube roots.
+
+#+BEGIN_SRC scheme
+
+  (define (qbrt x)
+    (qbrt-iter 1.0 x))
+  (define (qbrt-iter guess x)
+    (if (good-enough? guess x)
+	guess
+	(qbrt-iter (improve guess x)
+		   x)))
+  (define (cube x)
+    (* x x x))
+  (define (good-enough? guess x)
+    (< (abs (- (cube guess) x)) 0.001))
+  (define (improve guess x)
+    (/
+      (+
+       (/ x
+	  (* guess guess))
+       (* 2 guess))
+      3))
+  (qbrt 125)
+
+#+END_SRC
+
+#+RESULTS:
+: 5.000000000287929

1/1/jord/lecture.org

@@ -0,0 +1,81 @@
+* Lecture 1A
+https://youtu.be/-J_xL4IGhJA
+
+Welcome to "Computer" "Science"
+It's not a science
+It's not about computers
+
+*Process*, how to do things
+ - developing a way to talk about "how to" knowledge
+ - vs declarative knowledge, what things are
+*Procedures*
+
+Techniques for Controlling Complexity:
+ - Black-Box Abstraction
+ - Conventional Interfaces
+ - Metalinguistic Abstraction
+
+"procedures that talk about other procedures"
+
+-----------
+
+Essence of a computer language:
+  Primitive Elements
+  Means of Combination
+  Means of Abstraction
+
+
+     ,- operator    ,- operand
+   ( +   3   17.4   5) --> 25.4
+   `------------------' 
+       combination
+
+"prefix notation"
+"pretty printing"
+"syntactic sucar"
+
+(define (square x) (* x x)) is sugar for
+(define square (lambda (x) (* x x)))
+
+
+!! no distinction in lisp between arbitrary things and things built in
+
+#+BEGIN_SRC scheme
+  (define (try guess x)
+    (if (good-enough? guess x)
+	guess
+	(try (improve guess x) x)))
+  (define (sqrt x) (try 1 x))
+  (define (improve guess x)
+    (average guess (/ x guess)))
+  (define (good-enough? guess x)
+    (< (abs (- (square guess) x))
+       .001))
+#+END_SRC
+
+(sqrt 2)
+(try 1 2)
+(try (improve 1 2) 2)
+     `------------'
+      avg 1 (/ 2 1)
+(try 1.5 2)
+(try (average 1.5 (/ 2 1.5)) 2)
+(try 1.3333 2)
+
+
+BLOCK STRUCTURE
+
+to write lisp is to express imperitive knowledge
+
+|             | procedures      | data     |
+|-------------+-----------------+----------|
+| primitive   | +  /  >  =      | 12 143.7 |
+| elements    | - <             |   7      |
+|-------------+-----------------+----------|
+| means of    | ( ) composition |          |
+| combination |   cond  if      |          |
+|-------------+-----------------+----------|
+| means of    |  define         |          |
+| abstraction |                 |          |
+|-------------+-----------------+----------|
+

1/1/jord/notes.org

@@ -49,7 +49,6 @@ plan to use this for the majority of the examples
 
 isn't she pretty???
 
-
 ** 1.1.2 Naming and the Environment
 
 variables name an object that has a value
@@ -100,15 +99,13 @@ to eval primitives:
 
 (define g 6) is a special form
 
-
 ** 1.1.4 Compound Procedures
 essential powers of a programming language:
  -> numbers & arithmetic are primitive
  -> nesting allows combining
  -> definitions allow abstraction
 
-Procedure Definitons
-  \giving a name to a compound expression
+Procedure Definitons: giving a name to a compound expression
 
 #+BEGIN_SRC scheme :session sq :noweb yes
 
@@ -151,14 +148,15 @@ to eval a comp proc (assuming primitive built-in):
   -> eval the body with params replaced by args
 
  - substitution model (applicative-order) :: 
-        1. (f 5)
-        2. (sum-of-squares (+ a 1) (* a 2))
-        2b (sum-of-squares (+ 5 1) (* 5 2))
-        3. (sum-of-squares 6 10)
-        4. (+ (square 6) (square 10))
-        5. (+ (* 6 6) (* 10 10))
-        6. (+ 36 100)
-        7. 136
+   1. (f 5)
+   2. (sum-of-squares (+ a 1) (* a 2))
+   3. (sum-of-squares (+ 5 1) (* 5 2))
+   4. (sum-of-squares 6 10)
+   5. (+ (square 6) (square 10))
+   6. (+ (* 6 6) (* 10 10))
+   7. (+ 36 100)
+   8. 136
+   
 
 substitution is a mental model, not how it really works
 simplified, incomplete, will be refined as we continue
@@ -166,13 +164,13 @@ simplified, incomplete, will be refined as we continue
 lisp does use applicative order, compared to ...
 
  - normal-order evaluation ::
-        1. (f 5)
-        2. (sum-of-squares (+ 5 1) (* 5 2))
-        3. (+ (square (+ 5 1))  (square (* 5 2)))
-        4. (+ (* (+ 5 1) (+ 5 1)) (* (* 5 2) (* 5 2)))
-        5. (+ (* 6 6) (* 10 10))
-        6. (+ 36 100)
-        7. 136
+   1. (f 5)
+   2. (sum-of-squares (+ 5 1) (* 5 2))
+   3. (+ (square (+ 5 1))  (square (* 5 2)))
+   4. (+ (* (+ 5 1) (+ 5 1)) (* (* 5 2) (* 5 2)))
+   5. (+ (* 6 6) (* 10 10))
+   6. (+ 36 100)
+   7. 136
 
 ** 1.1.6 Conditional Expressions and Predicates
 
@@ -232,3 +230,54 @@ and, or are special procedures
     (not (< x y)))
 
 #+END_SRC
+
+** 1.1.8 Procedures as Black-Box Abstractions
+sqrt-iter is recursive; defined in terms of itself.
+computing sqrt breaks up naturally into subproblems.
+
+                                                  -> square
+                                                / 
+                            -- >  good-enough - 
+                          /                     \
+sqrt ---- > sqrt-iter --                          -> abs
+                          \
+                            -- >  improve    ---->   average
+
+a proc should supress this detail. users should not have
+to know about what is going on inside of sqrt.
+
+ - local names :: var names chosen by proc's author are irrelevant
+ - bound variable :: formal param of a proc
+ - free variable :: unbound
+ - scope :: set of exps for which a binding gives a name
+
+a procedure's formal params bind vars to its body's scope
+
+new! block structure:
+
+#+BEGIN_SRC scheme :session :noweb yes
+  (define (average x y)
+    (/ (+ x y)
+       2))
+  (define (square x)
+    (* x x))
+
+  (define (sqrt x)
+    (define (good-enough? guess x)
+      (< (abs (- (square guess) x)) 0.001))
+    (define (improve guess x)
+      (average guess (/ x guess)))
+    (define (sqrt-iter guess x)
+      (if (good-enough? guess x)
+          guess
+          (sqrt-iter (improve guess x) x)))
+    (sqrt-iter 1.0 x))
+
+  (sqrt 36)
+#+END_SRC
+
+#+RESULTS:
+: 6.000000005333189
+
+"we will use block structure extensively" (─‿‿─) 
+THE IDEA OF BLOCK STRUCTURE ORIGINATED WITH ALGOL-60