anchor.diff:                  else
                       let m = Array2D.length2 x
                       let n = Array2D.length1 x
  -                    if x.Length > parallelizationThreshold then
  -                        Array2D.Parallel.init m n (fun i j -> x.[j, i])
  -                    else
  -                        Array2D.init m n (fun i j -> x.[j, i])
  +                    Array2D.init m n (fun i j -> x.[j, i])
               member o.Sum_M(x) = // Non-BLAS
                   if Array2D.isEmpty x then
                       0.f
  
positive.code:             let m = Array2D.length1 a
              let n = Array2D.length2 a
              let a' = Array2D.zeroCreate n m
              if m * n > parallelizationThreshold then
                  for i = 0 to n - 1 do
                      Parallel.For(0, m, fun j -> a'.[i, j] <- a.[j, i]) |> ignore
              else
                  for i = 0 to n - 1 do
                      for j = 0 to m - 1 do
                          a'.[i, j] <- a.[j, i]
              let b' = Array.copy b
              let ipiv = Array.zeroCreate n
              let mutable arg_n = n
  
negative.code: open System.Runtime.InteropServices
  open FSharp.NativeInterop
  open System.Security
  open DiffSharp.Util
  
  /// Backend using OpenBLAS library for BLAS and LAPACK operations, and parallel threads for non-BLAS operations
  module OpenBLAS =
  
      type PinnedArray<'T when 'T : unmanaged> (array : 'T[]) =
          let h = GCHandle.Alloc(array, GCHandleType.Pinned)
  