In this assignment, you will experiment with generating images using the iterated image functions. Throughout the assignment, you will:

• Practice writing functions with names (e.g. named functions) and without names (e.g. anonymous functions)
• Practice the process of abstraction by relying on your work from Exercise 1
• Practice translating mathematical expressions into code

This assignment will give you practice with the process of abstracting programs. You’ll begin by writing very basic code, then gradually building up layers of abstraction to mask complexity, minimize repetition, and write reusable and generalizable patterns.

Exercise 2 Starter Files

Note: Like the last assignment, we’ve tried hard to provide instructions for those who have a difficult time seeing colors. Please let us know if any of the questions cause you issues.

Getting Started

Start by opening the exercise_2.rkt file. At the top of the definitions file you’ll see two require statements. Each asks DrRacket to import or load some external libraries (just like checking out a book from a real library):

(require 2htdp/image)
(require "./iterated-images.rkt")

The second line should look familiar, it loads the image library from our auxillary textbook “How to Design Programs (2E).” The second line asks DrRacket to load in the library we provided in your homework download. The ./ says “please look in the same folder as the file we’re currently editing” while the second part is the name of the file to load. We’ve written the require commands for you for this assignment but you will need to understand how they’re importing code for future assignments.

Part 1: Iterative Expressions

In this section, we’ll use three iterator functions: iterated-overlay, iterated-beside, iterated-below, and iterated-above. We covered these functions in class so checkout the lecture slides and recording for details.

For this part of the homework, we’ve provided placeholders or stubs for your code. Just look for the line that says something like:

(define question-1 "fill this in")

and replace the string “fill this in” with your answer. This will allow the tests to find your code.

Question 1: A Simple Bullseye

Part A

Use overlay to generate a "purple" bullseye consisting of five concentric circles. The smallest circle should have a radius of 20, and the largest should have a radius of 60. The circles should be an even distance apart.

Part B

Now use iterated-overlay to generate an image identical to your result from Part (a). Remember that iterators begin counting at 0, not 1, which means you may need to adjust your math slightly to avoid creating a circle with zero radius. If you’re getting something like the figure below (though in a different color), that’s probably what’s happening to you:

Question 2: Hexagonal Snowman

Use iterated-above to generate a snowman made out of 4 "purple" hexagons. The side-lengths of the hexagons should should range from 10 to 40.

Question 3: A Simple Flower

Use iterated-overlay to generate a flower. The rotate function might be helpful. You will need to use five ellipses defined as follows:

(ellipse 100 50 "solid" "olivedrab")

Question 4: A Colorful flower

Use iterated-overlay to generate a colorful flower. This flower should be identical to the previous one, except the ellipses should be colored accordingly:

• The first ellipse produced by iterated-overlay should be perfectly green, i.e. (color 0 255 0).
• Each successive ellipse should be 25 units more blue and 25 units less green than the previous ellipse.

Question 5: A Fancy Flower

Use iterated-overlay and interpolate-colors to generate a fancy flower. This flower should be similar to the previous one, except that each ellipse should have an alpha value of 128, meaning that the colors of the different ellipses will blend with the colors below them. Remember that alpha is the fourth argument to the color function!

You must use interpolate-colors in your implementation, starting with red and ending with blue. Remember that iteration starts at 0, so if you call an iterator n times, the final iteration will be n-1. You may need to adjust your math to make sure the fifth iteration is completely blue.

Start by writing your answer to use an alpha value of 255 and see if you can make it look like “midway” test image provided. Once it does, then change it to use an alpha value of 128 and it should look like the real image.

Part 2: Function Abstractions

Now that you’re familiar with the abstractions provided by the iterated library, we can start abstracting even more. In this section, you will write reusable functions to generate images from some template, but with even more flexibility.

Whenever you write a function, you should start by writing two comments: a signature and a purpose statement.

• The signature defines the name of the function, then a colon (:), its input arguments in order, an arrow (->), and then the type of return value (or output). It should almost read as an icebreaker statement for the function: “Hello, my name is doubler and I expect one number and then give you back a number.”
• The purpose statement is a brief human-readable description of what the function does.

Here’s what that looks like in practice:

;; doubler : number -> number
;; Takes a number and multiplies it by two
(define doubler
  (lambda (n)
    (* 2 n)))

Remember, any line that begins with a semi-colon is a comment which means it’s just a note to the programmer that the computer ignores.

In this assignment, we’ve provided you with signatures and purpose statements for the first few functions you need to define. Whenever signatures or purpose statements are not provided, you are required to write your own.

Reminder: Functions vs. Expressions

In Part 1, your answers (e.g. question-1 and so on) were expressions formed by calling other functions. They all simplified to images. In Part 2, your answers will be functions formed using lambda.

(circle 50 "solid" a-color)

(lambda (a-color)
  (circle 50 "solid" a-color))

(iterated-overlay
 (lambda (n)
   (square n "solid" "blue")) 5)

(lambda (number-of-iterations)
  (iterated-overlay
   (lambda (n)
     (square n "solid" "blue"))   
   number-of-iterations))

One way to summarize the difference is that expressions can be simplified to a concrete value of some kind, whereas functions have missing information (the arguments) which need to be filled in before we can simplify. When a function is called with that information, we can plug in the missing information and simplify.

Question 6: Paint Palettes

Write a function called palette that takes three arguments:

1. A start color
2. An end color
3. A number of squares to generate.

palette should return a single image, consisting of a row of 75x75 squares. The number of squares to generate is given by num-squares, the third function argument.

The leftmost square should have color color-1, and the rightmost square should have color color-2. The squares in between should evenly interpolate between the two colors. Again, remember that iteration starts at 0 and ends at n − 1.

Here’s a starter for your function definition:

;; palette: color color number number -> image
;; returns a single image, consisting of a row of 75x75 squares
;; the number of squares to generate is given by num-squares
(define palette
  (lambda (color-1 color-2 num-squares)
     ...))

Calling (palette (color 0 0 0) (color 255 255 255) 2) should produce a row consisting of two squares, one completely black and one completely white. If you have difficulty solving this problem, look back at all the functions you have used before. You can use as many of them as you want to solve this problem.

Question 7: Palette Grids

Using the palette function, you wrote in Question 6, write a function called palette-grid which takes four arguments:

1. A start color
2. An end color
3. A row count
4. A column count

palette-grid should return an image, a grid with num-rows rows and num-cols columns. Each grid cell should be a 75x75 square.

• Each row should interpolate evenly between the leftmost and rightmost color, like before.
• Each column should interpolate between the topmost color and white. However, the last column should not be completely white – this is different from what we’ve previously done. Specifically, if there are m rows, then the last row should stop 1 / m short of being completely white.

You must use the palette function you wrote in Question 6.

Here’s another starter for you:

;; palette-grid : color color number number -> image
;; create a grid of interpolated colors
(define palette-grid
  (lambda (color-1 color-2 num-rows num-cols)
    ...))

Question 8: Bullseye Revisited

Recall that in Question 1, you wrote two equivalent expressions to generate a bullseye consisting of 5 rings with an outer radius of 50. Wouldn’t it be great if we could generalize this template to create bullseyes with any radius size and number of rings? Of course it would be! Rhetorical questions are so great. Well, the great news is that’s exactly what you’re going to do next!

Write a function called bullseye/simple which takes three arguments:

1. A number of rings
2. A radius
3. A color

bullseye/simple should return an image of a bullseye with the specified number of rings. The outermost circle should have the specified radius. The lines of the bullseye should be the given color.

In contrast to previous functions, you must:

1. Write your own signature, purpose statement, and definition for bullseye/simple (see Questions 6 & 7 in the starter code for signature and purpose examples), and
2. Convert the two images provided in the .rkt file into test cases; that is make your own calls to check-expect that compare the value for a call for bullseye/simple to the image provided.

We’ve provided one complete test case to start you off. Specifically, calling

(bullseye/simple 5 50 "purple")

should produce a bullseye identical to your answer for both parts of Question 1. Compare your code for Questions 1(a), 1(b), and 8, and notice the increasing generalization.

Question 9: Colorful Bullseye

Write a function called bullseye/color which takes four arguments:

1. A number of rings
2. A radius
3. An inner color
4. An outer color

bullseye/color should return an image of a bullseye with the specified number of rings. The outermost circle should have the specified radius. The innermost ring should have a color given by the third argument, and the outermost ring should have a color given by the fourth argument. The intermediate rings should interpolate evenly between the two colors. While you can’t reuse the bullseye/simple function here, you should use its implementation for inspiration.

Again, you must write your own function signature, purpose (see Questions 6 & 7 in the starter code for signature and purpose examples), and definition. You must also convert the two provided images into test cases.

Double Checking Your Work

Just because your program passes the various included tests (i.e. check-expects) that does NOT mean you will get a 100. In many of these problems, particularly the last few, we’ve asked you to write some tests yourself by giving you specific recommendations. As we get later in the quarter, we will start including fewer and asking you to write your own.

Before turning your assignment in, run the file one last time to make sure that it runs properly and doesn’t generate any exceptions, and all the provided tests pass. Keep in mind that we will be generating DIFFERENT images using your functions to see if they work the way the assignment specifies. You will only submit your RKT file, not the iterated-images.rkt file – in this class you will NEVER submit anything than your work to Canvas.

Submission Details