Exam 2: Control

a. Write, but do not document, a predicate, (simple-drawing? value), that checks whether value meets the form of a simple drawing. That is, your predicate should check whether value has the form described above.

> (simple-drawing? drawing-unit-circle)
#t
> (simple-drawing? 4)
#f
> (simple-drawing? (drawing-hshift drawing-unit-square 5))
#t
> (simple-drawing? (drawing-group drawing-unit-circle drawing-unit-square))
#f
> (simple-drawing? (iota 8))
#f
> (simple-drawing? (list 'drawing 'ellipse RGB-BLACK "" 2 3 4 5))
#t
> (simple-drawing? (list 'drawing 'ellipse "black" "" 2 3 4 5))
#f

b. Write, but do not document, a predicate, (drawing-ellipse? val), that determines whether val is a drawing and is an ellipse. You can use the simple-drawing? predicate to first check whether a value is a drawing.

> (drawing-ellipse? drawing-unit-circle)
#t
> (drawing-ellipse? (drawing-scale drawing-unit-circle 23))
#t
> (drawing-ellipse? (drawing-hshift drawing-unit-circle -5))
#t
> (drawing-ellipse? drawing-unit-square)
#f
> (drawing-ellipse? "This is a drawing of an ellipse")
#f

Document and write a predicate, (drawing-circle? val), that determines whether val is a drawing and is a circle. (A circle is an ellipse with equal width and height.)

> (drawing-circle? drawing-unit-circle)
#t
> (drawing-circle? (drawing-scale drawing-unit-circle 5))
#t
> (drawing-circle? (drawing-hscale drawing-unit-circle 3))
#f
> (drawing-circle? (drawing-vshift drawing-unit-circle 18))
#t
> (drawing-circle? (drawing-hscale (drawing-vscale drawing-unit-circle 3) 3))
#t
> (drawing-circle? pi)
#f

Document and write a procedure, (drawing-area val), that finds the area of a drawing that is a rectangle or a circle. (You need not find the area of a non-circle ellipse.)

> (drawing-area drawing-unit-square)
1
> (drawing-area drawing-unit-circle)
0.7853981633974483
> (drawing-area (drawing-scale drawing-unit-circle 20))
314.1592653589793
> (drawing-area (drawing-hscale drawing-unit-circle 20))
drawing-area: Don't know how to find the area of that drawing.
> (drawing-area (drawing-hscale drawing-unit-square 20))
20
> (drawing-area (drawing-vscale (drawing-hscale drawing-unit-square 20) 15))
300

Document and write a procedure, (drawings-largest drawings), that takes a list of basic drawings (rectangles and circles) as a parameter and returns the drawing in the list which has the largest area.

In a recent homework assignment, you wrote a procedure, turtle-scale-polygon, that drew a sequence of polygons, each scaled by a certain amount. One disadvantage of that procedure is that the size of the polygons grows very rapidly. As an alternative, we might simply increase the size by a constant amount.

Write a procedure, (turtle-growing-polygon! turtle initial-side-length sides length-increment copies), that draws the given number of copies of the specified polygon, with each copy drawn with a side length length-increment larger than the previous side.

In the past few weeks, you've seen how to select the brightest color in a list or the darkest color in the list. But sometimes our criteria for selecting a color are a bit more complicated.

Consider the following procedure that computes one metric for the “distance” between two colors.

;;; Procedure:
;;;   rgb-distance
;;; Parameters:
;;;   rgb1, an RGB color
;;;   rgb2, an RGB color
;;; Purpose:
;;;   Find the "distance" between two colors, using a simple metric.
;;; Produces:
;;;   distance, a non-negative integer.
;;; Preconditions:
;;;   [No additional.]
;;; Postconditions:
;;;   If rgb1 = rgb2, then distance is 0.
;;;   Given three rgb colors, c1, c2, and c3, if c1 and c2 are likely
;;;     to be perceived as closer than c1 and c3, then
;;;     rgb-distance(c1,c2) < rgb-distance(c1,c3).
(define rgb-distance
  (lambda (rgb1 rgb2)
    (+ (abs (- (rgb-red rgb1) (rgb-red rgb2)))
       (abs (- (rgb-green rgb1) (rgb-green rgb2)))
       (abs (- (rgb-blue rgb1) (rgb-blue rgb2))))))

Document and write a procedure, (rgb-closest color candidates), that finds the element of candidates that is closest to color.

Note: You are likely to find it helpful to write a local helper, rgb-closer, that determines which of two candidates is closer to color

> (rgb->string (rgb-closest RGB-RED (list RGB-BLACK RGB-WHITE)))
"0/0/0"
> (rgb->string (rgb-closest RGB-YELLOW (list RGB-BLACK RGB-WHITE)))
"255/255/255"
> (rgb->string (rgb-closest RGB-RED (list RGB-BLACK RGB-RED RGB-WHITE)))
"255/0/0"
> (rgb->string (rgb-closest RGB-YELLOW (list RGB-BLACK RGB-RED RGB-WHITE)))
"255/255/255"
> (rgb->string (rgb-closest (rgb-new 255 128 0) (list RGB-BLACK RGB-RED RGB-WHITE)))
"255/0/0"

When computers had less memory, it was inefficient to represent each color by three values. More frequently, images were represented using palettes, in which each color was selected from a small list of colors. This approach is still used to send compressed versions of images across the Internet. It can also be used to create interesting variants of images.

Write a procedure, (palettize image colors), that creates a new image by converting the color at each pixel in image to the nearest color in colors.

(palettize kitten (list RGB-BLACK RGB-WHITE))

(palettize kitten (list RGB-BLACK RGB-GREY RGB-WHITE))

(palettize kitten (list RGB-GREY RGB-WHITE))

(palettize kitten (list RGB-RED RGB-WHITE RGB-BLUE))

It is often the case that there are multiple ways to write the same procedure. In this problem, you will write two versions of (drop-ends lst), a procedure that builds a new list from lst by dropping the first and last elements.

> (drop-ends (iota 10))
(1 2 3 4 5 6 7 8)
> (drop-ends (list "red" "orange" "yellow" "green" "blue"))
("orange" "yellow" "green")

a. Write drop-ends without using recursion with an appropriate combination of the basic list procedures like cons, car, cdr, reverse, and append You can also use the basic value null.

b. Write drop-ends using recursion explicitly and only the procedures cons, car, cdr, and null?. You may also use the basic value null.

c. Which version of drop-ends do you prefer? Why?

In writing both versions of drop-ends, you may assume that the preconditions of the procedure are met.

Rewrite one of your two versions of drop-ends so that it checks appropriate preconditions. Provide a separate error message for each kind of error.

In writing various types of recursive procedures, it is often helpful to generalize common code. For example, if we have a two-parameter procedure, such as max or drawing-leftmost, that selects one of its two parameters according to some priority, we can generalize it to a list of values using the following strategy.

(define GENERALIZED
  (lambda (lst)
    (if (null? (cdr lst))
        (car lst)
        (SELECT (car lst) (GENERALIZED (cdr lst))))))

Now, we can generalize max to largest by replacing GENERALIZED with largest and SELECT with max

(define largest
  (lambda (lst)
    (if (null? (cdr lst))
        (car lst)
        (max (car lst) (largest (cdr lst))))))

We can generalize drawing-leftmost to drawings-leftmost with a similar substitution.

(define drawings-leftmost
  (lambda (lst)
    (if (null? (cdr lst))
        (car lst)
        (drawing-leftmost (car lst) (drawings-leftmost (cdr lst))))))

We can take the next step by transforming our template into an actual procedure that takes the SELECT operation as one of its parameters. Since this process is called folding, we might call the procedure fold.

(define fold
  (lambda (select lst)
    (if (null? (cdr lst))
        (car lst)
        (select (car lst) (fold select (cdr lst))))))

Note that the only substantial difference is that we've included the select parameter in the recursive call to fold.

> (fold max (list 3 2 5 -4 0 1))
5
> (fold append (list (iota 3) (reverse (iota 3))))
(0 1 2 2 1 0)

a. We have now looked at a variety of ways to tally values. Write a generalized TALLY template that we can use to easily write new tally functions.

b. Transform your template into an actual procedure (tally pred? lst) that returns the number of times pred? holds for the values in lst.

> (tally odd? (iota 5))
2