Machine epsilon - find epsi
If we assume that a float is represented in memory as a (sign, mantissa, exponent) tuple, and assume a radix of 2, then we can find the machine epsilon exactly.  That is, if we can assume the machine stores floats using base-2 representations of the mantissa and exponent, then we know that:


The machine will store a value of 1 in floating point exactly - this would be stored as 1 for the mantissa, and 0 for the exponent, i.e. 1 * 2^0.
The machine will store all powers of two that it can represent using a single bit in the mantissa, and by varying the exponent.  E.g. 1/4 could be represented as 1 * (2 ^ -2).  Any representable power of two will be stored without losing information.
1 + epsi will be the smallest value greater than 1 that can be stored in the mantissa of the floating-point number.


EDIT

The second version looks much better than the first, but I believe there's an off-by-one error in the number of times you recurse in find-epsi.  I suggest that you create a test function, to see if your result is the machine epsilon:

(defun epsi-sig-p (epsi)
  (&gt; (+ 1.0 epsi) 1.0))


You'll probably find that (is-sig (find-epsi)) is #f...  This also suggests that you can refactor (under the DRY principle) find-epsi to use this test function in find-epsi:

(defun find-epsi (&amp;OPTIONAL (epsi 1.0))
  (if (epsi-sig-p epsi)
    (find-epsi (/ epsi 2))
    epsi))


but we didn't change the behavior to fix the calculation, yet.  For this, I'd suggest another routine, to check whether we should try the next possible epsi:

(defun next-epsi (epsi) (/ epsi 2))
(defun is-epsi-p (epsi)
  (and (epsi-sig-p epsi) (not (epsi-sig-p (next-epsi epsi)))))
(defun find-epsi (&amp;OPTIONAL (epsi 1.0))
  (if (is-epsi-p epsi)
    epsi
    (find-epsi (next-epsi epsi))))


is-epsi-p should return #t, now.