anchor.diff:                  if rowI <> index then
                       for colI=0 to nCols-1 do
                           nm.[nRowI,colI] <- m.[rowI,colI]
  -                    loop (nRowI-1) (rowI-1) 
  +                    loop (nRowI-1) (rowI-1)
                   else
  -                    loop (nRowI) (rowI-1) 
  -    
  +                    loop (nRowI) (rowI-1)
  +
           loop (nRows-2) (nRows-1)
   
       /// Removes a column at a given index
       let removeColAt index (m:Matrix<_>) =
           let nRows,nCols = m.Dimensions
           //let nm = Matrix.Generic.zero nRows (nCols-1)
  -        let nm = MG.zero nRows (nCols-1)
  +        let nm = MG.zeroCreate nRows (nCols-1)
           let rec loop nColI colI =
               if nColI < 0 then
                   nm
  
positive.code:         let to_dense a            = toDense a
          let init_dense i j a      = initDense i j a
          let init_sparse i j a     = initSparse i j a
          let nonzero_entries a     = MS.nonZeroEntriesM a 
          
          // TM
          /// Applies function f along row axis 
          let enumerateRowWise f (m:Matrix<'a>) =
              seq [ 
                  for rowi=0 to m.NumRows-1 do 
                  yield f (seq [for coli=0 to m.NumCols-1 do yield m.[rowi,coli]])
              ]  
  
          /// Maps every matrix row using the position dependant function
          let mapiRows (f: int -> RowVector<'a> -> 'b) (m:Matrix<'a>) =
  
negative.code:     /// Accesses the m*n matrix a and returns a total of j2 Columns starting from column index j1. The Result is a new
      /// m*j2 matrix.
      /// Only usable if (j1+j2-1) does not exceed n.
      let getCols (a:matrix) j1 j2 = MG.getCols a j1 j2
      /// Accesses the m*n matrix a and returns a total of i2 rows starting from row index i1. The Result is a new
      /// i2*n matrix.
      /// Only usable if (i1+i2-1) does not exceed m.
  