anchor.diff:  ;; (float-shift-digits 1.201d0)
   ;; => -3, 1201
   ;; ^ subtly works around a matter of floating point error
  -;;   i.e. in which
  -;;   (* 10  1.201d0)
  -;;   => 12.010000000000002d0
  -;;
  -;; so...
  -;; (integer-shift-digits 12010000000000000)
  -;; => 13, 1201
  -;;
  -;; (+ -16 13)
  -;; => -3
  -;;
  -;; (float (* 1201 (expt 10 -3)))
  -;; => 1.201
  -
  -#+NIL
  - (multiple-value-bind (scale-1 magnitude-1) 
  -     (float-shift-digits 1.201d0)
  -   (multiple-value-bind (scale-2 magnitude-2)
  -       (integer-shift-digits magnitude-1)
  -     (values (+ scale-1 scale-2) magnitude-2 )))
  -;; => -3, 1201
  -;;
  -;; (float (* 1201 (expt 10 -3)))
  -;; => 1.201
  -
  -;; n.b.
  -;; (float (* 12010000000000000 (expt 10 -16)))
  -;; => 1.201
  +;;   i.e. in which (* 10  1.201d0)
  +;;                  => 12.010000000000002d0
   
   ;; (float-shift-digits 1.201)
   ;; => -3, 1201
  
positive.code:     (declare (type (or integer float) b)
               (type fixnum n) )
      (loop  
         #+nil (format t "~%FROB: ~s" d)
         (setq b (* b 10))
         (multiple-value-bind (b r) 
             (truncate b)
           (cond
             ((zerop r) 
              ;; n.b: This effectively works around a matter
              ;; of floating point error - see following
              ;; comments
              (multiple-value-bind (scale-shift magnitude)
                  (integer-shift-digits
                   (truncate (* d (expt 10 n))))
                (return (values (- scale-shift n)
                                magnitude))))
             (t (incf n)))))))
  
  ;; (float-shift-digits 12)
  
negative.code:      (let ((n 0))
         (declare (fixnum n))
         (loop
            #+NIL (format t "~%FROB: ~s ~S" d n)
            (multiple-value-bind (a r)
                (truncate d 10) 
              (cond
  