anchor.diff:  ;; (* 10 4.159265358979312d0)
   ;; => 41.592653589793116d0
   ;;
  -;; and still there is some error:
  +;; so, until some further error filtering, there was an
   ;; (float-shift-digits 4.159265358979312d0)
  -;; => -15, 4159265358979311
  -;;
  -;; (=  4.159265358979312d0 (* 4159265358979311 (expt 10 -15)))
  -;; => NIL
  +;; => -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
   
  
positive.code: instances.
  
  This funcdtion implements a calculation similar to a base-10
  calculation of the significand and exponent of D, with D represented
  consistently as a floating point number. However, this function
  calculates only the significant digits in the decimal portion of D
  
  " 
    (declare (type (or integer float) d)
             (values fixnum integer))
    (let ((b d)
  
negative.code:     (declare (type (or integer float) b)
               (type fixnum n) )
      (loop  
         #+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 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 scaled-magnitude)
                (return (values (- scale-shift n)
                                magnitude)))))
             (t (incf n)))))))
  
  ;; (float-shift-digits 12)
  