anchor.diff:      /// computes the row specific sample covariance matrix of a data matrix 
       let rowSampleCovarianceMatrixOf (dataMatrix:Matrix<float>) =
           columnCovarianceMatrixOf (dataMatrix.Transpose.NumRows-1) dataMatrix.Transpose
  -
       //----------------------------------------------------------------------------
  -
   end
  -
   [<AutoOpen>]
   module MatrixExtension =
   
  
positive.code:                 for rowi=0 to m.NumRows-1 do 
                  yield f (seq [for coli=0 to m.NumCols-1 do yield m.[rowi,coli]])
                  ]    
  
      end
  
      module MG = Generic
  
negative.code: 
          // Accessors
          let get (a:Matrix<_>) i j   = a.[i,j]
          let set (a:Matrix<_>) i j x = a.[i,j] <- x              
          // Creation
          let ofList xss = MS.listM  xss
          let ofSeq xss  = MS.seqM  xss
          let init m n f = MS.initM  m n f
          let ofArray2D (arr: 'T[,])  : Matrix<'T> = MS.arrayM arr
          let toArray2D (m:Matrix<_>) = Array2D.init m.NumRows m.NumCols (fun i j -> get m i j)
          let initNumeric m n f = MS.initNumericM m n f
          let zero m n = MS.zeroM m n
          let identity m = MS.identityM m
          let create m n x = MS.constM m n x
          let ofScalar x = MS.scalarM x
          let diag v = MS.diagM v
          let initDiagonal v = MS.diagM v
          let constDiag n x = MS.constDiagM n x
            
          // Operators
          /// Performs a element wise addition of matrices a and b (a+b).
          /// Only usable if both matrices have the same dimensions.
          let add a b = MS.addM a b
          /// Performs a element wise substraction of matrices a and b (a-b).
          /// Only usable if both matrices have the same dimensions.
          let sub a b = MS.subM a b
          /// Performs a left sided matrix multiplication of a and b (a*b).
          /// Only usable if both matrices have the same dimensions.
          let mul a b = MS.mulM a b
          /// Performs a matrix multiplication of the 1*n rowvector a and the m*n matrix b (a*b).
          /// Only usable if column number (n) of the vector equals the row number (m) of the matrix.
          let mulRV a b = MS.mulRVM a b
          /// Performs a matrix multiplication m*n matrix a and the m*1 vector b (a*b).
          /// Only usable if column number (n) of the matrix equals the row number (m) of the vector.
          let mulV a b = MS.mulMV a b
          /// Performs a element wise multiplication of matrices a and b (a*b, Hadamard-Product).
          /// Only usable if both matrices have the same dimensions.
          let cptMul a b = MS.cptMulM a b
          /// Performs a element wise comparison of matrices a and b always preserving the greater value.
          /// Only usable if both matrices have the same dimensions.
          let cptMax a b = MS.cptMaxM a b
          /// Performs a element wise comparison of matrices a and b always preserving the smaller value.
          /// Only usable if both matrices have the same dimensions.
          let cptMin a b = MS.cptMinM a b
          /// Builds a new matrix where the elements are the result of multiplying every element of the given matrix with the given value
          let scale a b = MS.scaleM a b
          /// Performs a dot product of matrices a and b.
          /// Only usable if both matrices have the same dimensions.
          let dot a b = MS.dotM a b
          /// Scales matrix a by element wise mulitplication with minus 1.
          let neg a = MS.negM a        
          /// Computes the trace of matrix a by summing elements of the diagonal.
          /// Only usable if matrices a is a square matrix (m*m).
          let trace a = MS.traceM a
          /// Computes the sum all elements matrix elements.
          let sum a = MS.sumM a
          /// Computes the product of all matrix elements.
          let prod a = MS.prodM a
          ///
          let norm a = MS.normM a
          /// Returns the transpose of matrix a 
          let transpose a = MS.transM a
          /// Performs a element wise addition of matrices a and b (a+b).
          /// Attention: the output overrides matrix a.
          /// Only usable if both matrices have the same dimensions.        
          let inplaceAdd a b = MS.inplaceAddM a b
          /// Performs a element wise substraction of matrices a and b (a-b).
          /// Attention: the output overrides matrix a.
          /// Only usable if both matrices have the same dimensions.
          let inplaceSub a b = MS.inplaceSubM a b
          /// Iterates the given Matrix row wise and applies function f element wise.
          /// The iteration stops and returns true if an element satisfies the condition or false when the end of
          /// the matrix is reached.
          let exists f a = MS.existsM  f a
          /// Iterates the given Matrix row wise and applies function f element wise.
          /// The iteration stops and returns false if an element fails the condition or true when the end of
          /// the matrix is reached.
          let forall f a = MS.forallM  f a
          /// Iterates the given Matrix row wise and applies function f element wise.
          /// The iteration stops and returns true if an element satisfies the condition or false when the end of
          /// the matrix is reached.
          let existsi f a = MS.existsiM  f a
          /// Iterates the given Matrix row wise and applies function f element wise.
          /// The iteration stops and returns false if an element fails the condition or true when the end of
          /// the matrix is reached.
          let foralli f a = MS.foralliM  f a
          ///
          let map f a = MS.mapM f a
          ///
          let copy a = MS.copyM a
          ///
          let mapi f a = MS.mapiM f a
          ///
          let getDiagN a n = MS.getDiagnM a n
          ///
          let getDiag a = MS.getDiagnM a 0
          ///
          let toDense a = MS.toDenseM a 
          ///
          let initDense i j a = MS.initDenseM i j a 
          ///
          let initSparse i j a = MS.initSparseM i j a 
          ///
          let fold f z a = MS.foldM f z a
          ///
          let foldi f z a = MS.foldiM f z a
          ///  
          let compare a b = MS.compareM LanguagePrimitives.GenericComparer a b
          ///
          let hash a = MS.hashM LanguagePrimitives.GenericEqualityComparer a
          ///Returns row of index i of matrix a
          let getRow a i = MS.getRowM a i
          ///Replaces row of index j of matrix a with values of vector v, if vector length matches rowsize
          let setRow (a:Matrix<_>) j (v:Vector<_>) = MS.setRowM a j v
          ///Returns col of index j of matrix a
          let getCol a j = MS.getColM a j  
          ///Replaces column of index i of matrix a with values of vector v, if vector length matches columnsize
          let setCol (a:Matrix<_>) i (v:Vector<_>) = MS.setColM a i v
          ///
          let getCols a i1 i2 = MS.getColsM a (i1,i1+i2-1)
          ///
          let getRows a j1 j2 = MS.getRowsM a (j1,j1+j2-1)
          ///
          let getRegion a i1 j1 i2 j2 = MS.getRegionM a (i1,i1+i2-1) (j1,j1+j2-1)
          ///    
          let ofRowVector x = MS.rowvecM x
          ///
          let ofVector x = MS.vectorM x
          ///
          let toVector x = MS.toVectorM x
          ///
          let toRowVector x = MS.toRowVectorM x
          ///
          let toScalar x = MS.toScalarM x
              
          let inplace_assign f a    = MS.inplaceAssignM  f a
          let inplace_cptMul a b    = MS.inplaceCptMulM a b
          let inplace_scale a b     = MS.inplaceScaleM a b
          let inplace_mapi f a      = MS.inplace_mapiM f a
          let of_rowvec x           = ofRowVector x
          let of_vector x           = ofVector x
          let to_vector x           = toVector x
  