anchor.diff:                  if Array.isEmpty x then
                       Array.empty
                   else
  -                    if x.Length > parallelizationThreshold then
  -                        Array.Parallel.map f x
  -                    else
  -                        Array.map f x
  +                    Array.map f x
               member o.Map2_F_V_V(f, x, y) = // Non-BLAS
                   if Array.isEmpty x || Array.isEmpty y then
                       Array.empty
                   else
  -                    if x.Length > parallelizationThreshold then
  -                        Array.Parallel.map2 f x y
  -                    else
  -                        Array.map2 f x y
  +                    Array.map2 f x y
               member o.Map_F_M(f, x) = // Non-BLAS
                   if Array2D.isEmpty x then
                       Array2D.empty
                   else
  -                    if x.Length > parallelizationThreshold then
  -                        Array2D.Parallel.map f x
  -                    else
  -                        Array2D.map f x
  +                    Array2D.map f x
               member o.Map2_F_M_M(f, x, y) = // Non-BLAS
                   if Array2D.isEmpty x || Array2D.isEmpty y then
                       Array2D.empty
                   else
  -                    if x.Length > parallelizationThreshold then
  -                        Array2D.Parallel.map2 f x y
  -                    else
  -                        Array2D.map2 f x y
  +                    Array2D.map2 f x y
               member o.L1Norm_V(x) =
                   if Array.isEmpty x then
                       0.
  
positive.code:                     Array.empty
                  else
                      let n = min (Array2D.length1 x) (Array2D.length2 x)
                      if n > parallelizationThreshold then
                          Array.Parallel.init n (fun i -> x.[i, i])
                      else
                          Array.init n (fun i -> x.[i, i])
              member o.Inverse_M(x) =
                  if Array2D.isEmpty x then
                      Some(Array2D.empty)
  
negative.code:                     Array.empty
                  else
                      let n = min (Array2D.length1 x) (Array2D.length2 x)
                      Array.init n (fun i -> x.[i, i])
              member o.Inverse_M(x) =
                  if Array2D.isEmpty x then
                      Some(Array2D.empty)
  