Exam 2: Control and Beyond

Topics: RGB colors, Procedures, Numbers

Sometimes we want to take two RGB colors and blend them in some way. For example, we might blend colors “smoothly” by taking an average over their components. At other times we may want more drastic combinations. For example, we might want to use only the more intense or the less intense of each color component.

Write a procedure, (rgb-min-blend color1 color2), that takes two RGB colors, and creates a new RGB color where each component (red, green, and blue) is the smaller of the corresponding component of the two colors.

> (rgb->rgb-list (rgb-min-blend (color->rgb "white") (color->rgb "black")))
(0 0 0)
> (color->rgb-list "mistyrose")
(255 228 225)
> (color->rgb-list "lemonchiffon")
(255 250 205)
> (rgb->rgb-list (rgb-min-blend (color->rgb "mistyrose") (color->rgb "lemonchiffon")))
(255 228 205)
> (color->rgb-list "springgreen")
(0 255 127)
> (color->rgb-list "bisque")
(255 228 196)
> (rgb->rgb-list (rgb-min-blend (color->rgb "springgreen") (color-name->rgb "bisque")))
(0 228 127)

Topics: RGB colors, color transformations, local bindings, code reading, concision

Consider the following procedure.

;;; Procedure:
;;;   rgb-greyer
;;; Purpose:
;;;   To make a color greyer while preserving its hue.
;;; Parameters:
;;;   color, an rgb color
;;;   weight, a real number
;;; Produces:
;;;   greyer, an rgb color
;;; Preconditions:
;;;   0 <= weight <= 1
;;; Postconditions:
;;;   If weight is 0, then greyer is equal to color
;;;   If weight is 1, then greyer is equal to (rgb-greyscale color)
;;;   (rgb->hue greyer) = (rgb->hue color)
;;;     (unless weight is 1; then the hue of greyer will be 0)
;;;   (rgb->value greyer) <= (rgb->value color)
;;;   (rgb->saturation greyer) <= (rgb->saturation color)
;;; Process:
;;;   Each component of the color is blended with the color's grey value
;;;     in proportion to weight.
(define rgb-greyer
  (lambda (color weight)
    (rgb-new (+ (* (- 1 weight) (rgb-red color))
                (* weight
                   (+ (* 0.30 (rgb-red color))
                      (* 0.59 (rgb-green color))
                      (* 0.11 (rgb-blue color)))))
             (+ (* (- 1 weight) (rgb-green color))
                (* weight
                 (+ (* 0.30 (rgb-red color))
                    (* 0.59 (rgb-green color))
                    (* 0.11 (rgb-blue color)))))
             (+ (* (- 1 weight) (rgb-blue color))
                (* weight
                   (+ (* 0.30 (rgb-red color))
                      (* 0.59 (rgb-green color))
                      (* 0.11 (rgb-blue color))))))))

Notice that this procedure is very repetitive. Using let and/or let*, rewrite this procedure as concisely as you can.

Topics: Transforming images, anonymous procedures, sectioning

Write, but do not document, a procedure (image-greyer image weight), which transforms all of the pixels in image using rgb-greyer. Note that providing 0 for the weight parameter will result in no change to the image, whereas providing 1 will result in a greyscale image.

Write this procedure as concisely as you can.

Topics: Turtles, iteration

Consider the following procedure, which uses the given turtle and side length to draw a single square.

(define turtle-square!
  (lambda (turtle side-length)
    (repeat 4 (lambda () 
                (turtle-forward! turtle side-length)
                (turtle-turn! turtle 90)))))

What if we wanted to draw a sequence of squares, like so?

Write, but do not document, a procedure, (turtle-square-sequence! turtle copies side-length spacing), that draws the specified number of squares, each of the specified size. Each square should be offset from the previous square by the specified spacing.

You need not return the turtle to its original position and orientation.

You may not use recursion to solve this problem. You must use for-each or repeat. You should use the given turtle-square! procedure.

Your procedure should produce results similar to the following examples.

	(define world (image-show (image-new 300 50))) (define tia (turtle-new world)) (turtle-teleport! tia 10 10) (turtle-square-sequence! tia 12 10 10)
	(define world (image-show (image-new 300 50))) (define tia (turtle-new world)) (turtle-teleport! tia 10 10) (turtle-square-sequence! tia 8 30 5)
	(define world (image-show (image-new 200 200))) (define tia (turtle-new world)) (repeat 6 (lambda () (turtle-teleport! tia 100 100) (turtle-turn! tia 60) (turtle-square-sequence! tia 5 10 10)))

Topics: Turtles, iteration

Now suppose we want to extend our sequence of squares so that the spacing between squares systematically varies, like so:

Write, but do not document, a procedure, (turtle-square-progression! turtle copies side-length spacing-factor) that draws the specified number of squares, each of the specified size. The second square should be offset from the first by a distance of spacing-factor. Each subsequent square should be offset by an additional distance of spacing-factor.

You need not return the turtle to its original position and orientation.

You may not use recursion to solve this problem. You must use for-each or repeat. You should use our definition of turtle-square! from the previous problem.

Your procedure should produce results similar to the following examples.

	(define world (image-show (image-new 300 50))) (define tia (turtle-new world)) (turtle-teleport! tia 10 10) (turtle-square-progression! tia 7 10 10)
	(define world (image-show (image-new 300 50))) (define tia (turtle-new world)) (turtle-teleport! tia 10 10) (turtle-square-progression! tia 6 30 5)
	(define world (image-show (image-new 200 200))) (define tia (turtle-new world)) (repeat 6 (lambda () (turtle-teleport! tia 100 100) (turtle-turn! tia 60) (turtle-square-progression! tia 5 10 5)))

Topics: Core list operations, Recursion

You know that car and cdr are two basic operations for extracting the first element of a list and all but the first element of a list. Surprisingly, Scheme doesn't have procedures for getting the last and all but the last element from a list. (Okay, it's not so surprising: The underlying implementation of lists makes implementing car and cdr quick and straightforward. But the implementation makes getting the last element much less efficient.)

Using recursion (direct or helper), implement two procedures, rac and rdc, that get the last element of a list and all but the last element of the list. Hints for the implementation can be found in the Process section of the 6+P documentation below. Your procedures need not check preconditions.

In writing rac and rdc, the only list procedures you may use are car, cdr, cons, and null?. You may also use the special value null.

;;; Procedure:
;;;   rac
;;; Parameters:
;;;   lst, a nonempty list
;;; Purpose:
;;;   Find the last element of lst.
;;; Produces:
;;;   last, a value
;;; Preconditions:
;;;   [No additional]
;;; Postconditions:
;;;   last is the last element of lst.
;;; Process:
;;;   Repeatedly take the cdr until we reach the last element.

;;; Procedure:
;;;   rdc
;;; Parameter:
;;;   lst, a nonempty list
;;; Purpose:
;;;   Create a new list by removing the last element of lst
;;; Produces:
;;;   newlst, a list
;;; Preconditions:
;;;   [No additional]
;;; Postconditions:
;;;   (length newlst) = (- (length lst) 1)
;;;   For all i, 0 <= i < (- (length lst) 1)
;;;     (list-ref newlst i) = (list-ref lst i)
;;; Process:
;;;   Repeatedly take the cdr until we reach the last element.
;;;   Discard it.  Then either build the list back up, or deal
;;;   with the list we've accumulated along the way.

Topics: Lists, Problem solving, Precondition testing

In the previous problem, we asked you to write two procedures using only the basic list operations so that you could think about the underlying design of lists. Using those basic list operations required you to explicitly recurse through the list.

However, it is possible to write both rac and rdc much more concisely if you rely on some of the other list operations.

Write versions of rac and rdc that do not use explicit recursion. This time, both procedures should check their preconditions (in particular, the precondition that the parameter is a nonempty list) and report an appropriate error if the preconditions are not true.

Topics: Recursion, predicates, and, or

Write and document a procedure, (increasing? numbers), that returns #t if every number in the list (except the last) is less than or equal to the number immediately after it, and returns #f otherwise.

> (increasing? (iota 10))
#t
> (increasing? (reverse (iota 10)))
#f
> (increasing? (list 1/10 1/2 1/3 5/6))
#f
> (increasing? (list 0 1 1 2 3 3 10))
#t

While your inclination may be to write this procedure using if (or when, or cond), for full credit you should avoid using if (or when or cond).

Topics: Higher-order programming, Order of evaluation, Drawings as values, Code clarity

As you may have noted, one of the issues of the way we designed the drawing procedures is what we call “the German problem” - we have to wait a long time for an important part of information (in German, it's the verb; in these procedures, it's typically the amount by which we're transforming a drawing).

However, higher-order approaches, such as composition and sectioning, can help clarify things. For example, consider the following procedure, that scales a drawing, shifts it, and recolors it.

(define drawing-munge
  (lambda (drawing)
    (drawing-hshift
     (drawing-vshift
      (drawing-scale
       (drawing-recolor
        drawing
        "red")
      2)
     20)
    30)))

Using the higher-order procedures, we can write this somewhat clearer version.

(define drawing-munge
  (let ([munge (o (r-s drawing-hshift 30)
                  (r-s drawing-vshift 20)
                  (r-s drawing-scale 2)
                  (r-s drawing-recolor "red"))])
    (lambda (drawing)
      (munge drawing))))

As you will note, the operations are clearer: horizontally shift by 30, vertically shift by 20, scale by 2, and recolor red. It's still a bit awkward that we do them in bottom-to-top order, but that's something we get used to.

You may recall the smaller-right-neighbor procedure that you've written in labs and on a previous exam. That procedure creates a version of the drawing that is scaled by 75%, immediately to the right of the original, and with the same top.

Re-write the smaller-right-neighbor procedure using composition and sectioning, as suggested above.

Topics: Code reading, testing, recursion, documentation

As you've probably noted, we like to write long procedure names that make it perfectly clear what procedures are supposed to do. These procedures have names like image-compute-pixels! or rgb-complement. We also try to choose good names for the variables and parameters in our code.

However, in the interest of concision, some programmers prefer to give their procedures and variables short names, such as f and x. Some pay little attention to formatting.

Unfortunately, such short names can obfuscate code, particularly when combined with a lack of care in formatting. For example, consider the following useful procedure.

(define w (lambda (x y) (cond [(null? y) 0] [(equal? x (car y)) (+ 1 (w x (cdr y)))] [else (w x (cdr y))])))

Make this procedure definition easier to read as follows.

First, reformat the procedure so that the indentation properly demonstrates nesting. That is, you should choose appropriate points to put in carriage returns. Remember that DrRacket will re-indent for you after you put in those returns, as long as you select the text and type Tab.

Then, figure out what the procedure does. After doing so, change the names in the procedure to clarify the roles of various things. You should certainly rename the procedure w and the parameters x and y. (As a hint, start by figuring out what type y should be.)

Finally, write introductory comments (the six P's) to explain the purpose (and the other P's) of the procedure formerly named w. Pay particular attention to the preconditions.

When you format your exam, please put the introductory comments before the revised procedure definition.