anchor.diff:                          Some(det)
                       | _ -> None
               // 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
  +            // Non-BLAS
  +            member o.Sum_V(x) =
  +                if Array.isEmpty x then
  +                    0.
  +                else
  +                    Array.sum x
  +            // Non-BLAS
  +            member o.Mul_Had_M_M(x, y) =
  +                if Array2D.isEmpty x then
  +                    Array2D.zeroCreate (Array2D.length1 y) (Array2D.length2 y)
  +                elif Array2D.isEmpty y then
  +                    Array2D.zeroCreate (Array2D.length1 x) (Array2D.length2 x)
  +                else
  +                    (o :> Backend<float>).Map2_F_M_M((*), x, y)
  +            // Non-BLAS
  +            member o.Sum_M(x) =
  +                if Array2D.isEmpty x then
  +                    0.
  +                else
  +                    (o :> Backend<float>).ReshapeCopy_MRows_V(x) |> Array.sum
  +            // Non-BLAS
  +            member o.Diagonal_M(x) =
  +                if Array2D.isEmpty x then
  +                    Array.empty
  +                else
  +                    let n = min (Array2D.length1 x) (Array2D.length2 x)
  +                    Array.init n (fun i -> x.[i, i])
  +
  +            // Non-BLAS
               member o.ReshapeCopy_MRows_V(x) =
                   if Array2D.isEmpty x then
                       Array.empty<float>
  
positive.code:                     let z' = (o :> Backend<float32>).RepeatReshapeCopy_V_MCols(n, z)
                      BLAS.sgemm(1.f, x, y, 1.f, z')
                      z'
              // Non-BLAS
              member o.Mul_Had_M_M(x, y) =
                  if Array2D.isEmpty x then
                      Array2D.zeroCreate (Array2D.length1 y) (Array2D.length2 y)
                  elif Array2D.isEmpty y then
                      Array2D.zeroCreate (Array2D.length1 x) (Array2D.length2 x)
                  else
                      (o :> Backend<float32>).Map2_F_M_M((*), x, y)
              // BLAS
              member o.Mul_M_V(x, y) =
                  if Array2D.isEmpty x then
  
negative.code: 
      module BLASExtensions =
          [<SuppressUnmanagedCodeSecurity>]
          [<DllImport("libopenblas", EntryPoint="cblas_simatcopy")>]
          extern void cblas_simatcopy(int ordering, int trans, int rows, int cols, float32 alpha, float32 *a, int lda, int ldb)
  
          [<SuppressUnmanagedCodeSecurity>]
          [<DllImport("libopenblas", EntryPoint="cblas_somatcopy")>]
          extern void cblas_somatcopy(int ordering, int trans, int rows, int cols, float32 alpha, float32 *a, int lda, float32 *b, int ldb)
  
          // A <- alpha * transpose(A)
          // Only works for square matrices, modification of .NET array metadata might be needed for the correct in-memory transposition of non-square matrices
          let simatcopyT(alpha:float32, a:float32[,]) =
              let m = Array2D.length1 a
              let n = Array2D.length2 a
              let arg_ordering = 101 // cblas.h: typedef enum {CblasRowMajor=101, CblasColMajor=102} CBLAS_LAYOUT;
              let arg_trans = 112 // cblas.h: typedef enum {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113} CBLAS_TRANSPOSE;
              let arg_rows = m
              let arg_cols = n
              let arg_alpha = alpha
              let arg_a = new PinnedArray2D<float32>(a)
              let arg_lda = n
              let arg_ldb = m
              cblas_simatcopy(arg_ordering, arg_trans, arg_rows, arg_cols, arg_alpha, arg_a.Ptr, arg_lda, arg_ldb)
  
          // B <- alpha * transpose(A)
          let somatcopyT(alpha:float32, a:float32[,], b:float32[,]) =
  