anchor.diff:              let work = Array.zeroCreate (n * n)
               let mutable arg_n = n
               let mutable arg_lda = n
  -            let mutable arg_lwork = n * n
  +            let mutable arg_lwork = work.Length
               let mutable arg_info = 0
               use arg_a = new PinnedArray2D<float32>(a)
               use arg_ipiv = new PinnedArray<int>(ipiv)
  
positive.code:                     let z = Array2D.zeroCreate x.Length y.Length
                      BLAS.dger(1., x, y, z)
                      z
              // Non-BLAS
              member o.Sub_S_V(alpha, x) =
                  if alpha = 0. then 
                      (o :> Backend<float>).Mul_S_V(-1., x)
                  else
                      (o :> Backend<float>).Map_F_V((fun v -> alpha - v), x)
              // Non-BLAS
              member o.Sub_V_S(x, alpha) =
                  if alpha = 0. then
                      x
                  else
                      (o :> Backend<float>).Map_F_V((fun v -> v - alpha), x)
              // Non-BLAS
              member o.Sub_S_M(alpha, x) =
                  if alpha = 0. then 
                      (o :> Backend<float>).Mul_S_M(-1., x)
                  else
                      (o :> Backend<float>).Map_F_M((fun v -> alpha - v), x)
              // Non-BLAS
              member o.Sub_M_S(x, alpha) =
                  if alpha = 0. then
                      x
                  else
                      (o :> Backend<float>).Map_F_M((fun v -> v - alpha), x)
              // Non-BLAS
              member o.Map_F_V(f, x) =
                  if Array.isEmpty x then
                      Array.empty
                  else
                      Array.map f x
              // Non-BLAS
              member o.Map2_F_V_V(f, x, y) =
                  if Array.isEmpty x || Array.isEmpty y then
                      Array.empty
                  else
                      Array.map2 f x y
              // Non-BLAS
              member o.Map_F_M(f, x) =
                  if Array2D.isEmpty x then
                      Array2D.empty
                  else
                      Array2D.map f x
              // Non-BLAS
              member o.Map2_F_M_M(f, x, y) =
                  if Array2D.isEmpty x || Array2D.isEmpty y then
                      Array2D.empty
                  else
                      Array2D.map2 f x y
              // BLAS
              member o.L1Norm_V(x) =
                  if Array.isEmpty x then
  
negative.code:                     let z' = (o :> Backend<float32>).RepeatReshapeCopy_V_MCols(n, z)
                      BLAS.sgemm(1.f, x, y, 1.f, z')
                      z'
              // BLAS
              member o.Mul_M_V(x, y) =
                  if Array2D.isEmpty x then
  