## Homework Assignment 3

### Higher-Order Functions in Racket

#### Introduction

Template Source File
This assignment gives you your first chance to write and use higher-order functions in Racket. Download the file homework03.rkt and use it as a template for your submission. Please use the name homework03.rkt for your file!

This file again requires the rackunit package for unit testing. The template file includes space for you to write your test cases.
Do Not Use...
You do not need any Racket features to solve these problems beyond things we have learned in class and things discussed in this assignment.
• Do not use a let expression in any function.
• Do not use an internal define in any function.
In particular, do not use explicit recursion or looping in any function. Your solutions to Problems 3, 4, and 5 should use higher-order functions such as map and apply to do their jobs.
• string->number converts a string that contains a number into the equivalent number.

• exact->inexact converts an exact number (an integer or a fraction) into the equivalent floating-point number.

• You may pass a two-argument function to map. If you do, pass two list arguments, not one. map will pass the corresponding items in each list to the function at the same time:
```    > (map + '(1 3) '(2 7))      ; computes (+ 1 2) and (+ 3 7)
'(3 10)
```
Organizing Code
• Use a comment to indicate where the code for each problem begins and ends.
• Put any helper functions you write for a problem immediately before the tests for the main function of the problem.

#### Problems

1. For Problem 3 of Homework 2, you wrote a candy-temperature function to implement a common conversion from The Joy of Cooking. However, programmers who makes candy in the same city most of the time are forced to send theor city's elevation as an argument to the function every time. This is inconvenient.

Write a Racket function named candy-temperature-at that takes one number as an argument: elevation (in feet) of a given location. candy-temperature-at returns a function that takes one argument, a temperature (in degrees Fahrenheit) to use for a candy. The returned function returns as its value the temperature to use for that candy at the specified elevation. For example:
```     > ((candy-temperature-at 5280) 302)
291.44

> (define temp-in-cf
(candy-temperature-at 959))

> (temp-in-cf 240)     ;; fudge!
238.082
```
I have provided check-equal? expressions for these examples. Write at least two more check-equal? expressions to test your solution.

2. For Problem 4 of Homework 2, you wrote a function named in-range? that tests to see if two values are within a specified tolerance. When we work in engineering settings with such tolerances, the *epsilon* value is often fixed for most of our tests. Passing *epsilon* to the function every time we call it is inconvenient, but making *epsilon* a global variable creates bigger problems.

Write a Racket function named in-range-of that takes one number as an argument: the epsilon to use as a tolerance. in-range-of returns as its value a function that takes two number arguments. The returned function returns true if the difference between its arguments is less than epsilon, and false otherwise. For example:
```     > ((in-range-of 0.1) 4.95 5.0)
#t

> ((in-range-of 0.1) 5.0 4.95)     ;; works both ways
#t

> (define within-0.01?
(in-range-of 0.01))

> (within-0.01? 4.95 5.0)           ;; not anymore!
#f

> (within-0.01? 5.0 4.99)
#t
```
I have provided check-equal? expressions for these examples. You do not have to write any more tests for this problem.

3. Suppose that we have a list containing height/weight pairs for a group of people, in inches and pounds, respectively:
```     ( (76 . 195) (81 . 212) (79 . 225) (78 . 206) ... )
```
We would like to know the average weight of the people in the group.

Use higher-order functions such as map and apply to define a Racket function named average-weight. This function takes a list of height/weight pairs as its only argument and returns the the average weight of the group. For example:
```     > (average-weight '((79 . 225)))
225.0

> (average-weight '((70 . 150) (62 . 100)))
125.0
```
Assume that we have already written a variable-arity function named average. You may write other helper functions if you like, but you do not have to.

I have provided check-equal? expressions for these examples. Write at least two more check-equal? expressions to test your solution.

4. A buddy of mine wrote a program that predicts the results of college basketball games (pretty well, I might add). At the end of a week, he would like to know how far his program's predictions were from the actual results. His program has generated a list of predicted difference/actual difference pairs:
```     ( (2 -7) (-4 -20) (7 8) (-13 2) ... )
```
The first item in this list says that his program predicted Team 1 would win by 2 points, but Team 2 won by 7 points. For that game, his program was off by abs(2 - (-7)) == abs(9) == 9 points. The third item says that his program predicted that Team 1 would win by 7 points and that it won by 8 points, so his program was off by abs(7 - 8) == abs(-1) == 1 point. The list can contain any number of these pairs.

(This, too, is not much of a supposition... He wrote his program in Lisp, an ancestor of Racket, and he can surely write a simple expression to produce such a list from his database!)

Write a Racket function named total-error that takes one argument, a list of this form. The function returns the total of all the differences in the list. For example:
```     > (define example '((2 -7) (-4 -20) (7 8) (-13 2)))
> (total-error example)
41
```
I have provided a check-equal? expression for this example. Write at least three more check-equal? expressions to test your solution.

5. To monitor enrollments each semester, I have a spreadsheet that contains a list of courses with names, enrollments, and capacities. I read the spreadsheet data into a Racket list that looks like this:
```     '(("Dept" "Number" "Section" "Class Nbr" "Capacity" "Enrollment")
("CS" "1000" "1" "11546" "30" "30")
("CS" "1025" "1" "11547" "30" "30")
("CS" "1120" "1" "11557" "30" "15")
("CS" "1130" "1" "11548" "30" "18")
... )
```
The dean and provost frequently ask me for various summary data, such as total enrollments or remaining capacity.

Write a Racket function named max-open-seats that takes such as a list as its only argument. It returns the maximum number of open seats available in any section. The number of open seats is the difference between capacity and enrollment. For example:
```     > (define example '(...))     ; the data shown above
> (max-open-seats example)
15
```
CS 1120 has 30-15 = 15 open seats. The other classes have 0, 0, and 12 open seats each.

I have provided a check-equal? expression for this example. Write at least three more check-equal? expressions to test your solution.

#### Deliverables

By the due time and date, submit electronically the following file:

• homework03.rkt, the source file containing your function definitions and test cases

Be sure that your submission follows the submission requirements.

Eugene Wallingford ..... wallingf@cs.uni.edu ..... January 26, 2018