anchor.diff:            (unless (= #.(flt 0) damping-factor)
               (sum-nodes-and-old-nodes chunks
                                        (flt (- 1 damping-factor))
  -                                     (flt damping-factor))))))
  +                                     (flt damping-factor)))))
  +  (map nil #'nodes->means chunks))
   
   (defun settle-visible-mean-field
       (bm &key (supervisor (default-mean-field-supervisor bm)))
  
positive.code:         on (rest (clouds-up-to-layers dbm))
          while layer
          do (swap-nodes layer-below)
          (hijack-means-to-activation layer clouds-up-to-layer dbm)
          ;; Double activations of chunks in LAYER that have connections
          ;; to LAYER-ABOVE.
          (dolist (chunk layer)
            (when (and (not (conditioning-chunk-p chunk))
                       (connects-to-p chunk layer-above
                                      clouds-up-to-layer-above))
              (matlisp:scal! #.(flt 2) (nodes chunk))))
          (map nil #'set-chunk-mean layer)
          (swap-nodes layer-below)))
  
  (defun down-dbm (dbm)
    "Do a single downward pass in DBM, propagating the mean-field much
  
negative.code:                        (clouds dbm))))
    (check-dbm-clouds dbm))
  
  (defun conditioning-cloud-p (cloud)
    (or (conditioning-chunk-p (chunk1 cloud))
        (conditioning-chunk-p (chunk2 cloud))))
  
  (defun conditioning-clouds-to (chunks clouds)
    (remove-if-not (lambda (cloud)
                     (and (conditioning-cloud-p cloud)
                          (or (member (chunk1 cloud) chunks)
                              (member (chunk2 cloud) chunks))))
                   clouds))
  
  (defun up-dbm (dbm)
    "Do a single upward pass in DBM, performing approximate inference.
  Disregard intralayer and downward connections, double activations to
  