anchor.diff:              (ignore-errors (chunk-max-n-stripes chunk))))
     chunk)
   
  +;;; Currently the lisp code handles only the single stripe case and
  +;;; blas cannot deal with no missing values.
  +(defun check-stripes (chunk)
  +  (let ((indices-present (indices-present chunk)))
  +    (assert (or (null indices-present)
  +                (= 1 (chunk-n-stripes chunk))))))
  +
   (defun use-blas-on-chunk-p (cost chunk)
  -  (assert (or (null (indices-present chunk))
  -              (= 1 (chunk-n-stripes chunk))))
  -  (and
  -   ;; several stripes or cost is high => blas
  -   (or (< 1 (chunk-n-stripes chunk))
  -       (use-blas-p cost))
  -   ;; there is no missing value support in blas
  -   (null (indices-present chunk))))
  +  (check-stripes chunk)
  +  (cond ((indices-present chunk)
  +         ;; there is no missing value support in blas
  +         nil)
  +        (t
  +         ;; several stripes or cost is high => blas
  +         (or (< 1 (chunk-n-stripes chunk))
  +             (use-blas-p cost)))))
   
   (defun ->chunk (chunk-designator chunks)
     (if (typep chunk-designator 'chunk)
  
positive.code:          (shared (factored-cloud-shared-chunk cloud))
           (v* (storage v))
           (shared* (storage (nodes shared))))
      (with-segment-gradient-accumulator ((start accumulator accumulator2)
                                          ((cloud-a cloud) trainer))
        (when (and accumulator start)
  
negative.code:                                accumulator
                                 accumulator2)))
            (if (and (zerop start)
                     (null (indices-present visible-chunk)))
                (matlisp:gemm! (flt 1) v b (flt 0) x :tt)
                (let ((b* (storage b)))
                  (declare (optimize (speed 3) #.*no-array-bounds-check*))
                  (matlisp:fill-matrix x (flt 0))
                  (do-stripes (visible-chunk)
                    (do-chunk (i visible-chunk)
                      (let ((v*i (aref v* i)))
                        (unless (zerop v*i)
                          (loop for j of-type index upfrom 0 below c
                                for bi of-type index
                                upfrom (the! index (* i c)) do
                                (incf (aref shared* j)
                                      (* v*i (aref b* bi))))))))))
            (matlisp:gemm! (flt (if addp 1 -1)) h x
                           (flt 1) (reshape2 accumulator
                                             (matlisp:nrows a)
  