anchor.diff:        (return-from next eop))
       (decf-remaining pwxrand)
       (let* ((clist (next list))
  -           (cweights (cumulative-list (if (eql weights :equal)
  -                                          (let ((len (length clist)))
  -                                            (make-list len :initial-element (/ 1 len)))
  -                                          (normalized-sum (mapcar #'next (next weights)))))))
  -      (setf last-result (loop :for res := (nth (index-of-greater-than (random 1.0) cweights) clist)
  +           (clist-length (length clist))
  +           (cweights (next weights))
  +           (cweights (cumulative-list (if (eql cweights :equal)
  +                                          (make-list clist-length :initial-element (/ 1 clist-length))
  +                                          (normalized-sum (mapcar #'next cweights))))))
  +      (setf last-result (loop :for res := (nth-wrap (index-of-greater-than (random 1.0) cweights) clist)
                                 :if (or (not (slot-boundp pwxrand 'last-result))
                                         (not (eql res last-result)))
                                   :return res)))))
  
positive.code: ;; (next-upto-n (pexprand 1.0 8.0 4))
  ;; ;=> (1.0420843091865208d0 1.9340168112124456d0 2.173209129035095d0 4.501371557329618d0)
  
  See also: `pwhite', `pbrown', `pgauss', `prand'"
    :defun (defun pexprand (&optional (lo 0.0001) (hi 1.0) (length :inf))
             (assert (and (numberp lo)
                          (not (zerop lo)))
                     (lo)
                     "~s's LO argument must be a nonzero number; got ~s" 'pexprand lo)
             (assert (and (numberp hi)
                          (not (zerop hi)))
                     (hi)
                     "~s's HI argument must be a nonzero number; got ~s" 'pexprand hi)
             (make-instance 'pexprand
                            :lo lo
                            :hi hi
                            :length length)))
  
  (defmethod next ((pexprand pexprand-pstream))
    (with-slots (lo hi) pexprand
  
negative.code:     (decf-remaining pexprand)
      (let ((nlo (next lo))
            (nhi (next hi)))
        (assert (and (numberp lo)
                     (not (zerop lo)))
                (lo)
                "Got a zero for ~S's ~S slot" 'pexprand 'lo)
        (assert (and (numberp hi)
                     (not (zerop hi)))
                (hi)
                "Got a zero for ~S's ~S slot" 'pexprand 'hi)
        (when (or (eop-p nlo)
                  (eop-p nhi))
          (return-from next eop))
  