CS 257 (Fall 2001) Project 1: E. coli we hardly knew ye. *

• Problem 1 (Bacterial Chemotaxis)

• Problem 2 (Macro Expansion)

  Write a function, cond->if, which takes a cond expression as its argument and returns the equivalent expression using if's. For example:

  > (cond->if '(cond ((= x 1) 'foo) ((= x 2) 'bar) (else 'error)))
  (if (= x 1) (quote foo) (if (= x 2) (quote bar) (quote error)))
  > 
  

  You may assume that every cond expression has an else part.

• Problem 3 (Recognizing Tail Recursive Definitions)

  The function, foo, is a <tail function> if it is defined as follows:

  (define foo (lambda (<symbol>*) <tail expression>))

  An expression is a <tail expression> with respect to foo if it contains no applications of foo:

  <expression>

  or

  if it is an application of foo to zero or more expressions which contain no applications of foo:

  (foo <expression>*)

  or

  if all applications of foo are contained in expressions which are (themselves) tail recursive with respect to foo and which occur in any of the following contexts:
  • (if <expression> <tail expression> <tail expression>)
  • (and <expression>* <tail expression>)
  • (or <expression>* <tail expression>)

  where <symbol>* is zero or more symbols, <expression> is an expression which contains no applications of foo, <expression>* is zero or more expressions which contain no applications of foo, and <tail expression> is an expression which is tail recursive with respect to foo. Write a function, tail?, which takes a function definition as an argument, and returns #t if the defined function is a <tail function> and #f otherwise. For example:

  > (tail? '(define fact (lambda (x acc) (if (= x 0) acc (fact (- x 1) (* x acc))))))
  #t
  > (tail? '(define fact (lambda (x) (if (= x 0) 1 (* (fact (- x 1)))))))
  #f
  >
  

• Problem 4 (Polynomial Arithmetic)

  Get the code for polynomial arithmetic from the class homepage. Re-write the function, p*, which multiplies two polynomials, so that it is completely tail-recursive. Hint: This should be done in two parts. First, re-write the subroutine, t*, which multiplies a polynomial by a term so that it is tail-recursive. After you have tested p* and verified that it works correctly with the tail-recursive t*, then re-write p* itself, so that the entire function is tail-recursive. You will need to add tail-recursive subroutines to the letrec (e.g., t*-it and p*-it) to do this.

What You Should Hand In

• Listings of all your code.
• Representative graphic output (where applicable).

When You Should Hand It In

* This webpage is located at http://cs.unm.edu/~williams/cs257/project1f01.html