**Due by 11:59pm Wednesday, March 31**

- Study the code examples that we discussed in class this week.
- Read Sections
6.1, 6.2, and 6.3 of
*Concrete Abstractions*for next week.

In class this week, we wrote the function

`make-verifier`, which creates predicate functions to test for specific types of self-verifying numbers, such as ISBN and credit card numbers. Money order ID numbers are also self-verifying. To check if a number is a valid money order ID, we simply add up all of the digits of the number, except for the digit in position 1 (the rightmost digit). Instead, for the rightmost digit, we add the*negation*of that digit. If the resulting sum is divisible by 9, the number is a valid money order ID.Use

`make-verifier`to define the function**valid-money-order?**in the same way that we defined functions to test for valid ISBN, UPC, and credit card numbers. Then use your function to determine which of the following two numbers is a valid money order ID: 48077469777 or 48077462766.

We also wrote a few other functions in class, including

`map-both`and`sum`. Using`map-both`as a helper, define the function**zip**(from Lab 5), which takes two lists of equal length and returns a new list of lists with the corresponding elements paired up, as shown below:(zip '() '()) => () (zip '(a) '(b)) => ((a b)) (zip '(one two) '(fish fish)) => ((one fish) (two fish)) (zip '(1 2 3 4) '(a b c d)) => ((1 a) (2 b) (3 c) (4 d))

Using

`map-both`and`sum`as helpers, define the function**dot-product**, which takes two lists of numbers of equal length as input, multiplies the numbers at corresponding positions in the lists together, and adds up the results. For example, to compute the dot-product of the lists (4 3 2 1) and (10 20 30 40), we would compute the value:(4 × 10) + (3 × 20) + (2 × 30) + (1 × 40) = 40 + 60 + 60 + 40 = 200

(dot-product '(4 3 2 1) '(10 20 30 40)) => 200 (dot-product '(2 2 2) '(3 3 3)) => 18 (dot-product '() '()) => 0

Write the function

**weird-sqrt**, which takes a number*n*as input and returns its square root, except if*n*equals 0, in which case`weird-sqrt`should return the list`(you have won a million dollars!)`. For example:(weird-sqrt 25) => 5 (weird-sqrt 49) => 7 (weird-sqrt 0) => (you have won a million dollars!)

Write the function

**make-weird**, which takes three values as input: a one-argument function called*f*, a value called*special-input*, and another value called*special-output*, and returns a new function that behaves exactly like the function*f*, except when given*special-input*as input, in which case it should return the value*special-output*. For example, we could use`make-weird`to define`weird-sqrt`as shown below:(define weird-sqrt (make-weird sqrt 0 '(you have won a million dollars!)) (weird-sqrt 25) => 5 (weird-sqrt 0) => (you have won a million dollars!) (define weird-double (make-weird (lambda (x) (* 2 x)) 50 999)) (weird-double 3) => 6 (weird-double 10) => 20 (weird-double 50) => 999 (define weird-car (make-weird car '() 'oops)) (car '(1 2 3)) => 1 (car '(y z))) => y (car '()) => oops

Write the function

**(compose-all**, which takes a*list-of-functions*)*list*of one-argument functions and returns a new one-argument function representing their composition. If the list is empty, the "do nothing" identity function`(lambda (x) x)`should be returned. Hint: use`compose`as a helper and think recursively. Examples:((compose-all (list sqrt abs car)) '(-36 49 2)) => 6 ((compose-all (list car cdr)) '(a b c d e f)) => b ((compose-all (list car cdr cdr cdr)) '(a b c d e f)) => d ((compose-all (list car)) '(a b c d)) => a ((compose-all (list list list list)) 'crazy) => (((crazy))) ((compose-all '()) 42) => 42

The file

**recursive-arithmetic.scm**contains the code for the binary representation of numbers that we developed in class. This code uses the helper functions`get-last`,`remove-last`, and`add-to-end`to keep the binary digits in standard order, with the least-significant digit at the rightmost position of the list. But this approach is very inefficient, since`get-last`,`remove-last`, and`add-to-end`reverse their input list once or twice every time they are called. Rewrite**add1**and**sub1**using`car`,`cdr`, and`cons`in place of`get-last`,`remove-last`, and`add-to-end`, so that binary digits are added and removed from the*front*of the list instead of the end.This changes the representation of numbers (the binary digits are now stored in reverse order), but does it break the rest of the code? In other words, do we need to modify any other definitions in the code besides

`add1`and`sub1`in order for the arithmetic operations, and the conversion functions`num-to-rep`and`rep-to-num`, to work correctly with our new representation of numbers? If so, make the necessary modifications to the code. If not, explain why not in a brief comment in your file.

Save all of your Scheme definitions in a single text file named

**assign8.scm**. Make sure to include your name and the assignment number in a comment at the top of your file. Submit your file using the Homework Upload Site. Please do NOT email your file to me.If you have questions about anything, don't hesitate to ask!