Common Lisp Pipes→Enumerators

I've been plodding along through Peter Norvig's Paradigm's in Artificial Intelligence Programming and finding some helpful tips along the way. I especially enjoyed the discussion of pipes in chapter 9. I was intrigued by the pipes implementation of the sieve or Eratosthenes and wondered what else I could do with pipes.

Something that I didn't like about pipes is that they keep around a list of the results, when maybe you are actually done with those results. I was taking combinations of factors to produce a factorial experimental design and I decided to do so using something I have called multiple-radix-counting. Multiple-radix, meaning the radix (or base) for each digit is different. Imagine an odometer where each spinner has a different number of marks on it. Instead of always going from 0 to 9, some of the spinners might be 0 to 1 or 0 to 5. The sequencing is the same. When you get the end of the right most spinner, you wrap around on the first and advance the next spinner. Here's some sample output the shows the pattern:

(loop for enum = (multiple-radix-counter #(3 2 3) :terminate t) then (get-next enum) while enum do (print (get-current enum))) #(0 0 0) #(0 0 1) #(0 0 2) #(0 1 0) #(0 1 1) #(0 1 2) #(1 0 0) #(1 0 1) #(1 0 2) #(1 1 0) #(1 1 1) #(1 1 2) #(2 0 0) #(2 0 1) #(2 0 2) #(2 1 0) #(2 1 1) #(2 1 2) NIL

I have taken the definitions from PIAP and modified them to avoid hanging on to the part of the pipe that has gone past. I have renamed certain functions/macros and made minor changes to them to produce a result that behaves differently. Instead of make-pipe, I have make-enumerator, although the macro is identical. It's important that I have a new name for this macro that suits the different usage in case I decide to implement enumerators differently in the future. The function get-current and get-next are the replacements for head and tail, respectively.  The representation is very similar to that used for pipes. I use a cons cell where the car is the current value and the cdr is a function call.

(defmacro make-enumerator (head tail) `(cons ,head #'(lambda () ,tail))) (defun get-current (enumerator) (if (consp enumerator) (first enumerator) nil)) (defun get-next (enumerator) (when (functionp (rest enumerator)) (funcall (rest enumerator)))) (defun integer-enum (&optional (start 0) end) (if (or (null end) (<= start end)) (make-enumerator start (integer-enum (1+ start) end)) nil)) (defvar empty-indices '(nil)) ;; this is a non-destructive implmentation (defun multiple-radix-counter (radices &key indices terminate) (when (null indices) (setf indices (make-array (length radices) :initial-element 0))) (if (and terminate (equal indices empty-indices)) nil (make-enumerator indices (multiple-radix-counter radices :indices (loop with dest = (make-array (length indices) :initial-contents indices) for i from (1- (length indices)) downto 0 if (< (1+ (aref dest i)) (aref radices i)) do (incf (aref dest i)) (return dest) else do (setf (aref dest i) 0) finally (return (if (and terminate (< i 0)) empty-indices dest))) :terminate terminate)))) (defun extract-by-multiple-radix (source indices) (loop with res = (make-array (length indices)) for i from 0 to (1- (length indices)) do (setf (aref res i) (aref (aref source i) (aref indices i))) finally (return res)))

The purpose of the extract-by-multiple-radix is to take a selection out of source (an array of arrays) based on the indices that were specified. If you were doing multiplication of multiple term factors, you would take the terms by index from each factor and multiply them. To get the factors based on index, you would use extract-by-multiple-radix.