2.1 data abstractions

2/1/jord/exercises.org

@@ -0,0 +1,157 @@
+* Exercise 2.1
+better (positivity aware) make rat
+#+BEGIN_SRC scheme
+  (define (make-rat n d)
+    (if (< 0 d)
+        (cons (- n) (- d))
+        (cons n d)))
+#+END_SRC
+* Exercise 2.2
+#+BEGIN_SRC scheme :noweb yes :session segs
+  (define (make-point x y)
+    (cons x y))
+  (define (x-point pt)
+    (car pt))
+  (define (y-point pt)
+    (cdr pt))
+
+  (define (make-segment a b)
+    (cons a b))
+  (define (start-segment seg)
+    (car seg))
+  (define (end-segment seg)
+    (cdr seg))
+
+  (define (print-point p)
+    (display "(")
+    (display (x-point p))
+    (display ",")
+    (display (y-point p))
+    (display ")"))
+  (define (print-segment seg)
+    (newline)
+    (print-point (start-segment seg))
+    (display "->")
+    (print-point (end-segment seg)))
+
+  (define (midpoint-segment seg)
+    (define (average a b)
+      (/ (+ a b) 2))
+    (make-point (average (x-point (start-segment seg))
+			 (x-point (end-segment seg)))
+		(average (y-point (start-segment seg))
+			 (y-point (end-segment seg)))))
+#+END_SRC
+ 
+* Exercise 2.3
+
+#+BEGIN_SRC scheme :session segs
+  (define (make-rect p1 p2)
+    (cons p1 p2))
+
+  (define (side-length rect point-getter)
+    (let ((p1 (car rect))
+	  (p2 (cdr rect)))
+      (if (> (point-getter p1) (point-getter p2))
+	  (- (point-getter p1) (point-getter p2))
+	  (- (point-getter p2) (point-getter p1)))))
+  
+  (define (width rect)
+    (side-length rect x-point))
+  (define (height rect)
+    (side-length rect y-point))
+
+  (define (area rect)
+    (* (width rect)
+       (height rect)))
+  (define (perim rect)
+    (+ (* (width rect) 2)
+       (* (height rect) 2)))
+
+  (perim (make-rect (make-point 5 10) (make-point 1 1)))
+  
+#+END_SRC
+
+#+RESULTS:
+: 26
+* Exercise 2.4
+#+BEGIN_SRC scheme
+  (define (cdr z)
+    (z (lambda (p q) q)))
+#+END_SRC
+* Exercise 2.5
+#+BEGIN_SRC scheme
+  (define (pow a b)
+    (if (= 0 b)
+	1
+	(* a (pow a (- b 1)))))
+
+  (define (crazy-cons a b)
+    (* (pow 2 a)
+       (pow 3 b)))
+  (define (crazy-car x)
+    (define (cc-iter x val)
+      (if (= (remainder x 2) 1)
+	  val
+	  (cc-iter (/ x 2) (1+ val))))
+    (cc-iter x 0))
+  (define (crazy-cdr x)
+    (define (cc-iter x val)
+      (if (< x 2)
+	  val
+	  (cc-iter (/ x 3) (1+ val))))
+    (cc-iter (/ x (pow 2 (crazy-car x))) 0))
+  (crazy-car (crazy-cons 0 29))
+  (crazy-cdr (crazy-cons 30 7))
+  ;; only for positive integers
+#+END_SRC
+
+#+RESULTS:
+: 7
+
+works for all tested input. there could be a crazy edge case im
+missing? what a nutty problem.
+* Exercise 2.7
+here's alyssa's code for reference over the next few exercises
+#+BEGIN_SRC scheme :session aph :results none
+  (define (add-interval x y)
+    (make-interval (+ (lower-bound x) (lower-bound y))
+                   (+ (upper-bound x) (upper-bound y))))
+  (define (mul-interval x y)
+    (let ((p1 (* (lower-bound x) (lower-bound y)))
+          (p2 (* (lower-bound x) (upper-bound y)))
+          (p3 (* (upper-bound x) (lower-bound y)))
+          (p4 (* (upper-bound x) (upper-bound y))))
+      (make-interval (min p1 p2 p3 p4)
+                     (max p1 p2 p3 p4))))
+  (define (div-interval x y)
+    (mul-interval x
+                  (make-interval (/ 1.0 (upper-bound y))
+                                 (/ 1.0 (lower-bound y)))))
+  (define (make-interval a b) (cons a b))
+#+END_SRC
+
+#+BEGIN_SRC scheme :session aph
+  (define (upper-bound a)
+    (if (> (car a) (cdr a))
+        (car a)
+        (cdr a)))
+  (define (lower-bound a)
+    (if (< (car a) (cdr a))
+        (car a)
+        (cdr a)))
+  (lower-bound (make-interval 4 5))
+#+END_SRC
+
+#+RESULTS:
+: 4
+#+BEGIN_SRC scheme :session aph
+  (define (sub-interval x y)
+    (define (sml-sub a b)
+      (if (< a b)
+          (- b a)
+          (- a b)))
+    (make-interval (sml-sub (lower-bound x) (lower-bound-y))
+                   (sml-sub (upper-bound x) (upper-bound y))))
+	      
+#+END_SRC

2/1/jord/lecture.org

@@ -0,0 +1,267 @@
+* Lecture 2B Compound Data
+https://youtu.be/DrFkf-T-6Co
+
+so far we've been talking about procedures
+
+  - primitive things
+  - means of combination
+  - means of abstraction
+
+we've seen general methods for computing things
+
+the Crucial idea:
+
+!! We are building a layered system
+
+abstraction boundaries, ie 
+
+:        sqrt       ;; above the abstraction layer
+: /---------------\ ;; abstraction layer
+:     good-enuf?    ;; hidden parts
+
+divorce the task of building things from the task of building their
+parts. 
+
+now we will look at the same thing in terms of data
+
+  - primitive data
+  - glue for combining
+  - methodology for abstraction
+
+all of which we will do by building layers of abstraction.
+
+
+'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+the system we will be considering is rational numbers:
+  how to add, mul, sub, div fractions
+
+we dont /have/ a system for rational numbers
+
+scheme gives us a system for numbers, but not a number for a numerator
+and a denominator
+
+we will enable this by using the technique of 
+
+!! WISHFUL THINKING
+
+we will imagine we have these procedures
+
+:  (make-rat n d)     ;; -----> returns some 'cloud' containing n and d
+:  (numer **cloud**)  ;; -> takes in one of those 'clouds' and returns numerator 
+:  (denom **cloud**)  ;; -> takes in one of those 'clouds' and returns denominator
+
+how 'cloud' is made is not our problem: we dont want to know
+
+being able to leverage a 'cloud' though will give us the ability to
+work
+
+#+BEGIN_SRC scheme
+  (define (+rat x y)
+    (make-rat
+     (+ (* (numer x)(denom y))
+	(* (numer y)(denom x)))
+     (* (denom x) (denom y))))
+#+END_SRC
+
+no problem at all, if we have these 'clouds'
+
+we can also implement the product of 2 rats
+#+BEGIN_SRC scheme
+  (define (*rat x y)
+    (make-rat
+     (* (numer x) (numer y))
+     (* (denom x) (denom y))))
+#+END_SRC
+
+we assumed by wishful thinking that we had a data object
+
+we assumed we had a way to make one, a "constructor"
+  - make-rat
+
+we assumed we had ways to get things out, "selectors"
+  - denom
+  - numer
+
+without abstractions: more importantly thon confusing our programming,
+		      we might confuse our mind
+
+--> break
+
+we need a glue for data objects. lisp provides the glue via 
+
+LIST STRUCTURE
+  via PAIRS
+
+'cons' taking two args and returning a pair
+'car'  selecting the first part of a pair
+'cdr'  selecting the second part of a pair
+
+there is a "box and pointer" notation which i wont try to draw in
+ascii art here today
+
+with these data glue primitives, we can easily define the 'clouds'
+
+#+BEGIN_SRC scheme
+  (define (make-rat n d)
+    (cons n d))
+  (define (numer x) (car x))
+  (define (denom x) (cdr x))
+#+END_SRC
+
+for
+:  1     1
+: --- + ---
+:  2     4
+
+: (define a (make-rat 1 2))
+: (define b (make-rat 1 4))
+: (define ans (+rat a b))
+: (numer ans) ;; 6
+: (denom ans) ;; 8
+
+our implementation does not reduce to lowest terms
+
+#+BEGIN_SRC scheme
+  (define (make-rat n d)
+    (let ((g (gcd n d)))
+      (cons (/ n g)
+	    (/ d g))))
+#+END_SRC
+
+DATA ABSTRACTION:
+
+: we have *rat, +rat, etc     !!the use of data
+: -------------------------------------------
+:    abstraction layer: make-rat/numer/denom
+: -------------------------------------------
+: implemented via pairs       !!the representation of data
+
+ableson said "bs" O_O
+
+why bother with data abstraction?
+
+goes back to the sorceress' power over a spirit if she has its name
+
+when programming, we are forced to make decisions. in general, for
+flexibility, we'd like to never make a decision until we absolutely
+have to. there's a fine line between deferring decisions and outright
+procrastination. we'd like to make progress and also never be bound by
+the consequences of our decisions. data abstraction allows this. we
+used wishful thinking. WE GAVE A NAME TO THE DECISION. then we
+continued as if decisions had been made. sometimes the decision never
+has to be made.
+
+!! GJS: "there's a good part of computer science that's a lot like
+   magic. theres a bad part that's a lot like religion"
+
+---> break
+
+its not so great that we can do rational arithmetic. it is great that
+we can use these as building blocks for something more complex
+
+imagine points in a plane, like the point p(1,2)
+
+we can make a system for representing points in a plane
+
+#+BEGIN_SRC scheme
+  (define (make-vector x y) (cons x y))	;; constructor
+  (define (xcor p) (car p))		;; selector
+  (define (ycor p) (cdr p))		;; selector
+#+END_SRC
+
+given points in a plane, we might want to use them to build
+something. we might want to talk about line segments connecting
+points.
+
+#+BEGIN_SRC scheme
+  (define (make-seg p q) (cons p q))
+  (define (seg-start s) (car s))
+  (define (seg-end s) (cdr s))
+
+  (define (midpoint s)
+    (let ((a (seg-start s))
+	  (b (seg-end s)))
+      (make-vector
+       (average (xcor a) (xcor b))
+       (average (ycor a) (ycor b)))))
+  (define (length s)
+    (let
+	((dx (- (xcor (seg-end s))
+		(xcor (seg-start s))))
+	 (dy (- (ycor (seg-end s))
+		(ycor (seg-start s)))))
+      (sqrt (+ (square dx)
+	       (square dy)))))
+#+END_SRC
+
+here we have built a LAYERED SYSTEM
+
+:
+: SEGMENTS
+:
+: ----------------------------\ abstraction layer
+: make-seg/seg-start/seg-end
+: -----------------------------------------------
+:
+: VECTORS
+:
+: ----------------------------\ abstraction layer
+: make-vector/xcor/ycor
+: -----------------------------------------------
+:
+: PAIRS
+:
+
+this grows quite naturally bc pairs can themselves point to other
+pairs etc
+
+one of abelson's fav words:
+!! CLOSURE
+   when you put things together, you can then put those things
+   together, like pairs of pairs
+
+---> break
+
+"its always harder in computer science to talk about what something
+means than to go off and do it"
+
+with
+  - make-rat
+  - numer
+  - denom
+we have /abstract data/
+
+it fulfills a contract:
+
+: IF x = (make-rat n d)
+:   THEN
+:        (numer x)     n
+:        --------- =  ---
+:        (denom x)     d
+
+abelson:
+    "let me do something that i think is really going to terrify you"
+
+: AXIOM FOR PAIRS:
+:     FOR ANY x AND y
+:         (car (cons x y)) IS x
+:         (cdr (cons x y)) IS y
+
+what might we build pairs from? whats below the pair abstraction??
+abelson says pairs can be built from *nothing at all*, pure
+abstraction
+
+#+BEGIN_SRC scheme
+  (define (cons a b)
+    (lambda (pick)
+      (cond ((= pick 1) a)
+	    ((= pick 2) b))))
+  (define (car x) (x 1))
+  (define (cdr x) (x 2))
+#+END_SRC
+
+there are no data objects! only procedures! it's built out of air
+
+we dont need data at all to build data abstractions
+
+ONCE AGAIN we blur the line between data and procedure

2/1/jord/notes.org

@@ -0,0 +1,280 @@
+ch 1 recap:
+ - used primitive data (numbers) and primitive operations (arithmetic)
+ - combined procedures to form compound procedures through
+   - composition
+   - conditionals
+   - use of parameters
+ - saw that proocedures can be regarded as a pattern for local
+   evolution of a process
+ - classified, reasoned about, performed simple algorithmic analyses
+   of common patterns for processes embodied in procedures
+ - saw thath higher-order procedures empower us by allawing us to
+   manipulate and reason about general methods of computation
+this is much of the essence of programming
+
+now, we will approach complex data.
+
+programs typically model complex phenomena, and often, "we construct
+computational objocts that have seweral parts in ordor to model
+real-world phenomena that have several aspects"
+
+in ch 1 we made compound procedures. in ch2 we will use compound data
+
+coming up:
+  - compound data object :: data "glued together"
+  - data abstraction ::  isolating the parts of a program that deal
+       with how data is represented from the parts that deal with how
+       data is used
+  - abstraction barriers :: shielding a process from the more
+       primitive details it deals with
+
+!! the distinction between data and procedure continues to blur at a
+   breakneck pace
+
+  - closure :: the glue for combining data works with primitive as
+               well as compound data
+  - conventional interfaces :: combining program modules in a
+       mix-n-match fashion with compound data
+  - symbolic expressions :: data whose elements can be arbitrary
+       symbols
+  - generic operations :: operations that can handle many kinds of
+       data
+  - data-directed programming :: a technique that allows individual
+       data representations to be combined in isolation and combined
+       additively
+  - additively :: combining data representations without modification
+
+* 2.1 Introduction to Data Abstraction
+
+  - data abstraction :: isolating how a compound data object is used
+       from the details of how it's constructed
+  - selectors and constructors :: the interface between a concrete
+       data object and its abstract operations
+
+** 2.1.1 Example: Arithmetic Operations for Rational Numbers
+suppose...we want to do arithmetic with rational numbers
+
+we want to add, subtract, multiply, divide, and test for equality
+
+let's assume the selectors and constructors are available as
+procedures:
+
+  - (make-rat ⟨n⟩ ⟨d⟩) :: returns rational number with numerator n and
+       denominator d
+  - (numer ⟨x⟩) :: returns numerator of rational number x
+  - (denom ⟨x⟩) :: returns denominator of rational number x
+
+we can happily use wishful thinking here. these procedures do not
+exist, but we can pretend they do and build a suite of funtionality:
+#+BEGIN_SRC scheme :noweb yes :session rats
+  (define (add-rat x y)
+    (make-rat (+ (* (numer x) (denom y))
+                 (* (numer y) (denom x)))
+              (* (denom x) (denom y))))
+  (define (sub-rat x y)
+    (make-rat (- (* (numer x) (denom y))
+                 (* (numer y) (denom x)))
+              (* (denom x) (denom y))))
+  (define (mul-rat x y)
+    (make-rat (* (numer x) (numer y))
+              (* (denom x) (denom y))))
+  (define (div-rat x y)
+    (make-rat (* (numer x) (denom y))
+              (* (denom x) (numer y))))
+  (define (equal-rat? x y)
+    (= (* (numer x) (denom y))
+       (* (numer y) (denom x))))
+#+END_SRC
+we have operations based on the selector and constructor procedures
+  - numer
+  - denom
+  - make-rat
+but these don't exist yet. we need a way to glue together two numbers
+to make a rational number
+
+*** pairs
+  - pair :: a compound structure provided by lisp
+
+pairs can be constructed with the primitive procedure ~cons~
+given a pair, we can extract the elements with ~car~ and ~cdr~
+#+BEGIN_SRC scheme :noweb yes :session ccc
+  (define x (cons 1 2))
+  (car x)
+#+END_SRC
+
+#+RESULTS:
+: 1
+
+#+BEGIN_SRC scheme :session ccc
+  (cdr x)
+#+END_SRC
+
+#+RESULTS:
+: 2
+
+--> a note on terminology
+
+~cons~ is short for "construct"
+
+the other two harken back to the IBM 704 implementation of lisp. the
+machcine had an addressing scheme that had references to the "address"
+and "decrement" parts of a memory location.
+
+~car~ is short for "Contents of Address part of Register"
+~cdr~ is short for "Contents of Decrement part of Register"
+
+cdr is pronounced "could-er"
+
+#+BEGIN_SRC scheme
+  (define x (cons 1 2))
+  (define y (cons 3 4))
+  (define z (cons x y))
+  (car (car z)) ; 1
+  (car (cdr z)) ; 3
+#+END_SRC
+
+!! the single compound primitive pair, implemented by the procedures
+   ~cons~, ~car~, ~cdr~, is the only glue we need
+
+  - list-structured data :: data objects built by pairs
+
+*** TODO representing rational numbers
+#+BEGIN_SRC scheme :session rats
+  (define (make-rat n d) (cons n d))
+  (define (numer x) (car x))
+  (define (denom x) (cdr x))
+  (define (print-rat x)
+    (newline)
+    (display (numer x))
+    (display "/")
+    (display (denom x)))
+#+END_SRC
+including a tostr method, we can use our new procedures for great fun
+#+BEGIN_SRC scheme :session rats
+  (define one-half (make-rat 1 2))
+  (print-rat one-half)
+
+  (define one-third (make-rat 1 3))
+  (print-rat (add-rat one-half one-third))
+#+END_SRC
+this does not reduce the terms. we can do this if we have a gcd like
+back in 1.2.5
+#+BEGIN_SRC scheme
+  (define (make-rat n d)
+    (let ((g (gcd n d)))
+      (cons (/ n g) (/ d g))))
+#+END_SRC
+
+** 2.1.2 Abstraction Barriers
+there are abstraction barriers here
+
+------|programs that use rational nums|-------
+
+     rational numbers in problem domain
+
+------------|add-rat sub-rat ... |------------
+
+    rational numbers as numers and denoms
+
+------------|make-rat numer denom|------------
+
+          rational numbers as pairs
+
+----------------|cons car cdr|----------------
+
+         however pairs are implemented
+----------------------------------------------
+
+these abstraction barriers isolate the various levels of the system.
+at each level, the barrier separates the programs above from the
+programs below that implement the abstractions.
+the procedures at each level are the interfaces that define the
+abstraction barriers and connect the different levels.
+
+changing from one representation to another should have minimal
+(none??!!) effects on the levels above.
+
+** 2.1.3 What is Meant by Data?
+what is /data/, man?
+
+considering make-rat, for any int n and any nonzero int d, if x is
+(make-rat n d), this is true:
+
+:  (numer x)       n
+: -----------  =  ---
+:  (denom x)       d
+
+data is defined by some collection of selectors and constructors with
+specified conditions that the procedures must fulfil in order to be
+valid. 
+
+this pount of view can define high level data objects such as rats but
+also low level objects like pairs.
+
+the condition pair operations satisfy:
+  - if z is (cons x y)
+  - (car z) is x
+  - (cdr z) is y
+
+we could implement pairs with no data structures, only procedures
+#+BEGIN_SRC scheme
+  (define (cons x y)
+    (define (dispatch m)
+      (cond ((= m 0) x)
+            ((= m 1) y)
+            (else (error "argument not 0 or 1 -- CONS" m))))
+    dispatch)
+  (define (car z) (z 0))
+  (define (cdr z) (z 1))
+#+END_SRC
+this is an obscure but valid way to implement pairs.
+
+"procedural representations of data will play a central role in our
+programming repertoire."
+
+  - message passing :: this style of programming
+ 
+will visit this in ch 3 re the issues of modeling and simulation 
+
+** 2.1.4 Extended Exercise: Interval Arithmetic
+Alyssa P. Hacker is building some cool shit
+
+the system will give ability to manipulate inexact quantites with
+known precision, such as with resistors.
+
+calculate parallel resistance:
+:            1
+: Rp = -------------
+:       1/R1 + 1/R2
+
+alyssa postulates the existance of an abstract obj known as an
+"interval" with an upper and lower bound
+
+she presumes that given the endpoints of an interval, she can
+construct an interval with make-interval
+
+she writes a procedure for adding two intervals:
+#+BEGIN_SRC scheme
+  (define (add-interval x y)
+    (make-interval (+ (lower-bound x) (lower-bound y))
+                   (+ (upper-bound x) (upper-bound y))))
+#+END_SRC
+
+she also has a procedure for the product:
+#+BEGIN_SRC scheme
+  (define (mul-interval x y)
+    (let ((p1 (* (lower-bound x) (lower-bound y)))
+          (p2 (* (lower-bound x) (upper-bound y)))
+          (p3 (* (upper-bound x) (lower-bound y)))
+          (p4 (* (upper-bound x) (upper-bound y))))
+      (make-interval (min p1 p2 p3 p4)
+                     (max p1 p2 p3 p4))))
+#+END_SRC
+
+and the reciprocal, for division
+#+BEGIN_SRC scheme
+  (define (div-interval x y)
+    (mul-interval x
+                  (make-interval (/ 1.0 (upper-bound y))
+                                 (/ 1.0 (lower-bound y)))))
+#+END_SRC