anchor.diff:      (declare (type (or integer float) b)
                (type fixnum n) )
       (loop  
  -       #+nil (format t "~%FROB: ~s" d)
  +       #+NIL (format t "~%FROB.: ~s ~s" b n)
          (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
  +            ;; n.b: This effectively works around some matters
  +            ;; of floating point error, such as when 
  +            ;;
  +            ;; (* 10  1.201d0)
  +            ;;  => 12.010000000000002d0
  +            ;;
  +            ;; however
  +            ;; (float-shift-digits 1.201d0)
  +            ;; => -3, 1201
  +            (multiple-value-bind (scaled-magnitude r)
  +                ;; truncate so as to ensure an integral value is passed
  +                (truncate (* d (expt 10 n)))
  +              (unless (zerop r)
  +                ;; effectively, "Round up"
  +                ;;
  +                ;; e.g. when 
  +                ;;
  +                ;;   d = 4.159265358979312d0
  +                ;;   n = 15
  +                ;;
  +                ;; i.e
  +                ;;
  +                ;; (truncate (* 4.159265358979312d0 (expt 10 15)))
  +                ;;  => 4159265358979311, 0.5d0
  +                ;;
  +                ;; That may be a result of rounding in the floating
  +                ;; point implementation.
  +                ;;
  +                ;; Without the following adjustment, the containing
  +                ;; function would return an inaccurate value,
  +                ;; in that instance.
  +                (incf scaled-magnitude))
               (multiple-value-bind (scale-shift magnitude)
  -                (integer-shift-digits
  -                 (truncate (* d (expt 10 n))))
  +                (integer-shift-digits scaled-magnitude)
                 (return (values (- scale-shift n)
  -                              magnitude))))
  +                              magnitude)))))
              (t (incf n)))))))
   
   ;; (float-shift-digits 12)
  
positive.code:      (let ((n 0))
         (declare (fixnum n))
         (loop
            (multiple-value-bind (a r)
                (truncate d 10) 
              (cond
  
negative.code: ;; (* 10 4.159265358979312d0)
  ;; => 41.592653589793116d0
  ;;
  ;; so, until some further error filtering, there was an
  ;; (float-shift-digits 4.159265358979312d0)
  ;; => -15, 4159265358979312
  ;; previously => -15, 4159265358979311
  ;;
  ;; noticing:
  ;; (truncate (* 4.159265358979312d0 (expt 10 15)))
  ;; 4159265358979311, 0.5d0
  ;; ^ thus the additional filtering is defined
  
  ;; (truncate (* 1.201 (expt 10 3)))
  
  
  
  ;; sidebar: sb-impl::make-float
  
  