1.2 procedures and their processes

1/2/jord/example.org

@@ -0,0 +1,79 @@
+* 1.2.2 Counting Change
+How many different ways can we make change for $1.00, given
+half-dollars, quarters, dimes, nickels, pennies?
+
+the number of ways to change a using n types of coins is:
+  - the number of ways to change a using all but the first coin type, plus
+  - the number of ways to change (- a d) using all n coin types, d
+    being the denomination of first coin type
+
+#+BEGIN_SRC scheme
+  (define (count-change amount)
+    (cc amount 5))
+  (define (cc amount kinds-of-coins)
+    (cond ((= amount 0) 1)
+          ((or (< amount 0) (= kinds-of-coins 0)) 0)
+          (else (+ (cc amount
+                       (- kinds-of-coins 1))
+                   (cc (- amount (first-denomination kinds-of-coins))
+                       kinds-of-coins)))))
+  (define (first-denomination kinds-of-coins)
+    (cond ((= kinds-of-coins 1) 1)
+          ((= kinds-of-coins 2) 5)
+          ((= kinds-of-coins 3) 10)
+          ((= kinds-of-coins 4) 25)
+          ((= kinds-of-coins 5) 50)))
+  (count-change 100)
+#+END_SRC
+
+#+RESULTS:
+: 292
+* 1.2.6 Testing for Primality
+there are many ways to test for primeness
+** searching for divisors
+#+BEGIN_SRC scheme
+  (define (smallest-divisor n)
+    (find-divisor n 2))
+  (define (find-divisor n test-divisor)
+    (cond ((> (square test-divisor) n) n)
+          ((divides? test-divisor n) test-divisor)
+          (else (find-divisor n (+ test-divisor 1)))))
+  (define (divides? a b)
+    (= (remainder b a) 0))
+  (define (prime? n)
+    (= n (smallest-divisor n)))
+  (prime? 13)
+#+END_SRC
+
+#+RESULTS:
+
+** fermat's theorem
+if n is prime and a is any positive int less than n then a to the n is
+congruent to a modulo n
+
+numbers are congruent modulo n if they both have the same remainder
+when divided by n
+
+#+BEGIN_SRC scheme
+  (define (expmod base exp m)
+    (cond ((= exp 0) 1)
+          ((even? exp)
+           (remainder (square (expmod base (/ exp 2) m))
+                      m))
+          (else
+           (remainder (* base (expmod base (- exp 1) m))
+                      m))))
+  (define (fermat-test n)
+    (define (try-it a)
+      (= (expmod a n n) a))
+    (try-it (+ 1 (random (- n 1)))))
+  (define (fast-prime? n times)
+    (cond ((= times 0) true)
+          ((fermat-test n) (fast-prime? n (- times 1)))
+          (else false)))
+  (fast-prime? 6601 1)
+#+END_SRC
+
+the fermat test is a probabilistic algorithm, in that it gives you an
+answer that is /likely/ to be correct but not guaranteed. the odds
+of fooling it however, are small.

1/2/jord/exercises.org

@@ -0,0 +1,199 @@
+* 1.9
+
+#+BEGIN_SRC 
+(define (+ a b)
+  (if (= a 0)
+      b
+      (inc (+ (dec a) b))))
+(+ 4 5)
+(inc (+ (dec 4) 5))
+(inc (+ 3 5))
+(inc (inc (+ (dec 3) 5)))
+(inc (inc (+ 2 5)))
+(inc (inc (inc (+ (dec 2) 5))))
+(inc (inc (inc (+ 1 5))))
+(inc (inc (inc (inc (+ (dec 1) 5))))
+(inc (inc (inc (inc (+ 0 5)))))
+(inc (inc (inc (inc 5))))
+(inc (inc (inc 6)))
+(inc (inc 7))
+(inc 8)
+9
+#+END_SRC
+ this impl describes a recursive process.
+
+#+BEGIN_SRC 
+(define (+ a b)
+  (if (= a 0)
+      b
+      (+ (dec a) (inc b))))
+(+ 4 5)
+(+ 3 6)
+(+ 2 7)
+(+ 1 8)
+(+ 0 9)
+9
+#+END_SRC
+ this impl describes an iterative process
+
+* 1.10
+Ackerman's function:
+#+BEGIN_SRC scheme
+  (define (A x y)
+    (cond ((= y 0) 0)
+          ((= x 0) (* 2 y))
+          ((= y 1) 2)
+          (else (A (- x 1)
+                   (A x (- y 1))))))
+(A 2 4)
+#+END_SRC
+
+#+RESULTS:
+: 65536
+
+(A 1 10)
+(A 0 (A 1 9))
+(A 0 (A 0 (A 1 8)))
+(A 0 (A 0 (A 0 (A 1 7))))
+(A 0 (A 0 (A 0 (A 0 (A 1 6)))))
+(A 0 (A 0 (A 0 (A 0 (A 0 (A 1 5))))))
+(A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 1 4)))))))
+(A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 1 3))))))))
+(A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 1 2)))))))))
+(A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 1 1))))))))))
+(A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 0 2)))))))))
+(A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 0 4))))))))
+(A 0 (A 0 (A 0 (A 0 (A 0 (A 0 (A 0 8)))))))
+(A 0 (A 0 (A 0 (A 0 (A 0 (A 0 16))))))
+(A 0 (A 0 (A 0 (A 0 (A 0 32)))))
+(A 0 (A 0 (A 0 (A 0 64))))
+(A 0 (A 0 (A 0 128)))
+(A 0 (A 0 256))
+(A 0 512)
+1024
+
+(A 2 4)
+(A 1 (A 2 3))
+(A 1 (A 1 (A 2 2)))
+(A 1 (A 1 (A 1 (A 2 1))))
+(A 1 (A 1 (A 1 2)))
+(A 1 (A 1 (A 0 (A 1 1))))
+(A 1 (A 1 (A 0 2)))
+(A 1 (A 1 4))
+(A 1 (A 0 (A 1 3)))
+(A 1 (A 0 (A 0 (A 1 2))))
+(A 1 (A 0 (A 0 (A 0 (A 1 1)))))
+(A 1 (A 0 (A 0 (A 0 2))))
+(A 1 (A 0 (A 0 4)))
+(A 1 (A 0 8))
+(A 1 16)
+(A ... )
+65536
+
+(A 0 n): 2n
+(A 1 n): 2^n
+(A 2 n): 2^2^n
+
+* 1.11
+#+BEGIN_SRC scheme
+  (define (fn n)
+    (if (< n 3)
+        n
+        (+ (fn (- n 1))
+           (* 2 (fn (- n 2)))
+           (* 3 (fn (- n 3))))))
+  (fn 2)
+
+#+END_SRC
+
+#+RESULTS:
+
+this is the recursive approach. slow with even small numbers
+TODO: iterative approach
+
+* 1.12
+this is a pascal's triangle
+
+1:        1
+2:       1 1
+3:      1 2 1
+4:     1 3 3 1
+5:    1 4 6 4 1
+6:  1 5 10 10 5 1
+
+6, 6 = 1
+6, 1 = 1
+6, 2 = 5
+1, 1 = 1
+
+write a procedure that computes the elements recursively
+
+#+BEGIN_SRC scheme
+  (define (pascals row num)
+    (if (or (= row num) (= num 1) (= row 1))
+	1
+	(+ (pascals (- row 1) (- num 1))
+	   (pascals (- row 1) num))))
+  (pascals 6 4)
+#+END_SRC
+
+#+RESULTS:
+: 10
+
+* 1.17
+(define (* a b)
+  (if (= b 0)
+      0
+      (+ a (* a (- b 1)))))
+#+BEGIN_SRC scheme
+  (define (double a)
+    (mul a 2))
+  (define (halve a)
+    (/ a 2))
+  (define (fast-mul a b)
+  TODO
+#+END_SRC
+
+* 1.21
+find the lowest common divisor of 199, 1999, 19999
+#+BEGIN_SRC scheme
+  (define (smallest-divisor n)
+    (find-divisor n 2))
+  (define (find-divisor n test-divisor)
+    (cond ((> (square test-divisor) n) n)
+	  ((divides? test-divisor n) test-divisor)
+	  (else (find-divisor n (+ test-divisor 1)))))
+  (define (divides? a b)
+    (= (remainder b a) 0))
+
+  (smallest-divisor 199)
+  (smallest-divisor 1999)
+  (smallest-divisor 19999)
+#+END_SRC
+
+199:   199
+1999:  1999
+19999: 7
+
+* linear fibbonacci
+alluded to in the lecture, find a fast fibb computation
+#+BEGIN_SRC scheme
+  (define (fib n)
+    (fib-iter n 0 1 0))
+  (define (fib-iter n count sum last-sum)
+    (if (= count n)
+	last-sum
+	(fib-iter n (1+ count) (+ sum last-sum) sum)))
+  (fib 10)
+#+END_SRC
+
+#+RESULTS:
+: 55
+
+this is the linear version of the tree reversal from the lecture
+for this version,
+space = O(1)
+time  = O(n)
+
+the version in the lecture has time O(fib(n))
+calculating the 10th elem, O(fib(n)): 55 vs O(n): 10

1/2/jord/lecture.org

@@ -0,0 +1,151 @@
+* Lecture 1B
+https://youtu.be/V_7mmwpgJHU
+
+the spells we write direct a process
+
+#+BEGIN_SRC scheme
+
+(define (sum-of-squares x y)
+  (+ (square x) (square y)))
+(define (square x)
+  (* x x))
+(sum-of-squares 3 4) ;; --> 25
+
+#+END_SRC
+
+#+RESULTS:
+: 25
+
+we can develop mental models for how these processes behave
+the simplest of these is the *substitution model*
+
+KINDS OF EXPRESSIONS (* denotes special case):
+  - numbers
+  - symbols
+  - λ-expressions*
+  - definitions*
+  - conditionals*
+  - combinations
+
+SUBSTITUTION RULE:
+to evaluate an application,
+  - evaluate operator to get procedure
+  - evaluate operands to get arguments
+  - apply the procedure to the arguments
+    - copy body of the procedure, sub args for formal params
+    - exaluate resulting body
+
+(sum-of-squares 3 4)
+(+ (square 3) (square 4))
+(+ (square 3) (* 4 4))
+(+ (square 3) 16)
+(+ (* 3 3) 16)
+(+ 9 16)
+25
+
+learn to ignore details! what not to compute! what not to think!
+
+to evaluate an IF expr:
+  - evaluate the predicate
+    - if it yields TRUE
+      - evaluate consequent
+    - otherwise
+      - evaluate alternate
+(IF <predicate>
+    <consequent>
+    <alternative>)
+
+"any sorceror will tell you, if you have the name of something, you
+    have power over it"
+
+an important program we will revisit using "peano arithmetic"
+(define (+ x y)
+  (if (= x 0)
+      y
+      (+ (-1+ x) (1+ y))))
+
+(+ 3 4)
+(if (= 3 0) 4 (+ (-1+ 3) (1+ 4))
+(+ (-1+ 3) (1+ 4))
+(+ (-1+ 3) 5)
+(+ 2 5)
+(if (= 2 0) 5 (+ (-1+ 2 (1+ 5))))
+(+ 1 6)
+(+ 0 7)
+7
+
+** the shapes of programs for shapes of processes
+like photography, there are simple rules, but to be a creative person,
+we must be able to do analysis. to get an imagined result, what
+techniques must be employed.
+
+back to peano arithmetic, two ways to add whole numbers:
+(define (+ x y)
+  (if (= x 0)
+      y
+      (+ (-1+ x) (1+ y))))
+(define (+ x y)
+  (if (= x 0)
+      y
+      (1+ (+ (-1+ x) y))))
+
+#+BEGIN_SRC scheme
+
+;; (+ 3 4)         (+ 3 4)
+;; (+ 2 5)         (+1 (+ 2 4))
+;; (+ 1 6)         (+1 (+1 (+ 1 4)))
+;; (+ 0 7)         (+1 (+1 (+1 (+ 0 4))))
+;; 7               (+1 (+1 (+1 4)))
+;;                 (+1 (+1 5))
+;;                 (+1 6)
+;;                 7
+
+#+END_SRC
+
+on the left: time = O(x), space = O(1) ;;iterative!
+on the rght: time = O(x), space = O(x) ;;recursive!
+
+recursion is bureaucratic ("keeps more ppl employed!")
+iteration has all its state in its variables
+recursion keeps some information under the table
+
+
+
+here are some programs, using probably the worst way you can write
+them
+
+for fibbonacci numbers,
+(define (fib n)
+  (if (< n 2)
+      n
+      (+ (fib (- n 1))
+         (fib (- n 2)))))
+
+;                            fib 4
+;                         /         \
+;                 fib 3                   fib 2
+;               /      \                /       \
+;         fib 2         fib 1     fib 1           fib 0
+;       /       \         |         |               |
+; fib 1          fib 0    1         1               0
+;   |             |
+;   1             0
+
+time:  O(fib n)
+space: O(n)
+
+ppl think programming is hard bc you are describing a general process
+to describe any specific case.
+
+
+for towers of hanoi,
+(define (move n from to spare)
+  (cond ((= n 0) "done")
+        (else
+         (move (-1+ n) from spare to)
+         (print-move from to)
+         (move (-1+ n) spare to from))))
+(move-tower 4 1 2 3) ;; move 4-high tower using pegs 1, 2, 3
+(move-tower 3 1 3 2) - (move ...
+(move-tower 2 1 2 3) - (move ...
+(move-tower 1 1 3 2) - (move ...

1/2/jord/notes.org

@@ -0,0 +1,232 @@
+* 1.2 Procedures and the Processes they Generate
+"To become experts, we must learn to visualize the processes generated
+by various types of procedures"
+
+ - local evolution :: pattern defined by a procedure about how each
+      stage of the process is built off each other
+
+We make statements about the global behavior whose local evolution has
+been specified by a procedure.
+
+we will examine common process "shapes"
+
+** 1.2.1 Linear Recursion & Iteration
+
+there are numerous ways to calculate 6!
+
+linear recursive approach:
+
+#+BEGIN_SRC scheme
+
+  (define (factorial n)
+    (if (= n 1)
+      1
+      (* n (factorial (- n 1)))))
+  (factorial 6)
+
+#+END_SRC
+
+#+RESULTS:
+: 720
+
+linear iterative approach:
+
+#+BEGIN_SRC scheme
+
+  (define (factorial n)
+    (fact-iter 1 1 n))
+  (define (fact-iter product counter max-count)
+    (if (> counter max-count)
+	product
+	(fact-iter (* counter product)
+		   (+ counter 1)
+		   max-count)))
+  (factorial 6)
+
+#+END_SRC
+
+#+RESULTS:
+: 720
+
+here are the shapes of the two approaches, using the substitution model:
+
+#+BEGIN_SRC 
+
+;; linear recursive
+(factorial 6)
+(* 6 (factorial 5))
+(* 6 (* 5 (factorial 4)))
+(* 6 (* 5 (* 4 (factorial 3))))
+(* 6 (* 5 (* 4 (* 3 (factorial 2)))))
+(* 6 (* 5 (* 4 (* 3 (* 2 (factorial 1))))))
+(* 6 (* 5 (* 4 (* 3 (* 2 1)))))
+(* 6 (* 5 (* 4 (* 3 2))))
+(* 6 (* 5 (* 4 6)))
+(* 6 (* 5 24))
+(* 6 120)
+720
+
+;; linear iterative
+(factorial 6)
+(fact-iter 1 1 6)
+(fact-iter 1 2 6)
+(fact-iter 2 3 6)
+(fact-iter 6 4 6)
+(fact-iter 24 5 6)
+(fact-iter 120 6 6)
+(fact-iter 720 7 6)
+720
+
+#+END_SRC
+
+ - deferred operations :: the functions "stacking up" in the
+      l.r. model above
+ - recursive process :: characterized by a chain of deferred
+      operations
+ - iterative process :: state can be summarized by fixed number of
+      state variables
+ - linear recursive process :: a recursion where the chain of deferred
+      operations grows linearly with n
+ - linear iterative process :: an iteration where the number of steps
+      grows linearly with n
+
+the iterative approach maintains its own state, explicitly.
+when using recursion, state is hidden.
+
+!! don't confuse a recursive process with a recursive procedure
+
+ - tail recursion :: a language implementation that executes iterative
+                     processes in constant space, even if described by
+                     a recursive procedure
+
+languages such as c consume memory with each procedure call, even if
+the described process is iterative. this is not tail recursive. the
+IEEE standard for scheme requires that implementations be tail
+recursive.
+
+** 1.2.2 Tree Recursion
+
+          -- > 0		  if n = 0
+        /
+fib(n)  ---- > 1		  if n = 1
+        \
+          -- > fib(n-1)+fib(n-2)  else
+
+#+BEGIN_SRC scheme
+  (define (fib n)
+    (cond ((= n 0) 0)
+	  ((= n 1) 1)
+	  (else (+
+		 (fib (- n 1))
+		 (fib (- n 2))))))
+  (fib 7)
+#+END_SRC
+
+#+RESULTS:
+: 13
+
+#+BEGIN_SRC scheme
+  (define (fib n)
+    (fib-iter 1 0 n))
+  (define (fib-iter a b count)
+    (if (= count 0)
+	b
+	(fib-iter (+ a b) a (- count 1))))
+  (fib 8)
+#+END_SRC
+
+#+RESULTS:
+: 21
+
+the first impl traverses a tree. useful, but number of steps is very
+high, even with small inputs. the second impl is blazing fast by
+comparison, as a linear iter.
+
+** 1.2.3 Orders of Growth
+computational resources
+
+n is a param that measures the size of a problem
+R(n) is the amt of resources that n requires
+ϴ(f(n)) is R(n)'s order of growth
+
+growth can be constant, linear, exponential etc. "big o" shit
+
+the following algorithms in §1.2 will be logarithmic in growth
+
+** 1.2.4 Exponentiation
+how to compute an exponent?
+for 
+  b base
+  n positive integer exponent
+b^n = b * b^n-1
+b^0 = 1
+
+
+linear recursive process, ϴ(n) steps, ϴ(n) space:
+#+BEGIN_SRC scheme
+  (define (expt b n)
+    (if (= n 0)
+        1
+        (* b (expt b (- n 1)))))
+  (expt 9 9)
+#+END_SRC
+
+#+RESULTS:
+: 387420489
+
+linear iterative process, ϴ(n) steps, ϴ(1) space:
+#+BEGIN_SRC scheme
+  (define (expt b n)
+    (expt-iter b n 1))
+  (define (expt-iter b counter product)
+    (if (= counter 0)
+        product
+        (expt-iter b
+                   (- counter 1)
+                   (* b product))))
+  (expt 35 17)
+#+END_SRC
+
+#+RESULTS:
+: 1.7748299712158738e+26
+
+fast as hell method:
+#+BEGIN_SRC scheme
+  (define (fast-expt b n)
+    (cond ((= n 0) 1)
+          ((even? n) (square (fast-expt b (/ n 2))))
+          (else (* b (fast-expt b (- n 1))))))
+  (define (even? n)
+    (= (remainder n 2) 0))
+  (fast-expt 5 5)
+#+END_SRC
+
+#+RESULTS:
+
+** 1.2.5 Greatest Common Divisors
+a gcd is the largest int that can divide 2 ints with no remainder
+given ints a, b; r is the remainder of a/b
+gcd(a, b)==gcd(b, r) # br!
+
+euclid's algo (book 2 proposition 2): 
+gcd(206,40) = gcd(40, 6)
+            = gcd(6, 4)
+            = gcd(4, 2)
+            = gcd(2, 0)
+            = 2
+#+BEGIN_SRC scheme
+  (define (gcd a b)
+    (if (= b 0)
+        a
+        (gcd b (remainder a b))))
+  (gcd 81 18)
+#+END_SRC
+
+#+RESULTS:
+: 9
+
+!! euclid's algo has logorithmic growth
+
+  - Lamé's theorem :: a euclid algo taking k steps to solve a gcd, the
+                      smaller of the two numbers is greater or equal
+                      to the kth fibonacci number