anchor.diff:      let inplace_sub a b = VecDS.inplaceSubVecDS a b
       let inplace_cptMul a b = VecDS.inplaceCptMulVecDS a b
       let inplace_scale a b = VecDS.inplaceScaleVecDS a b  
  -
  +    ///Builds vector from array
       let of_array arr   = ofArray arr
  +    ///Builds array from vector
       let to_array m     = toArray m
  +    ///Builds vector from list
       let of_list    xs  = ofList xs
  +    ///Builds vector from sequence
       let of_seq    xs   = ofSeq xs
  +    ///Builds one dimensional vector from scalar
       let of_scalar x    = ofScalar x
       
       
  
positive.code: //--------------------------------------------------------------------------*)
        
  [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module Vector = 
  
      module Generic = 
  
          module OpsS = SpecializedGenericImpl
  
          let get (a:Vector<_>) i   = a.[i]
          let set (a:Vector<_>) i x = a.[i] <- x
          let length (v:Vector<_>) = v.Length
          let ofList    xss   = OpsS.listV xss
          let ofSeq    xss   = OpsS.seqV xss
          let init  m   f = OpsS.initV m f
          let initNumeric  m   f = OpsS.createNumericV m f
          let ofArray arr       = OpsS.arrayV arr
          let toArray (v:Vector<_>) = Array.init v.Length (get v)
  
          let create  m x   = OpsS.constV m x
          let zero n = OpsS.zeroV n
          let ones n = OpsS.createNumericV n (fun ops _ -> ops.One)
          let ofScalar   x = OpsS.scalarV x
          let add a b = OpsS.addV a b
          let sub a b = OpsS.subV a b
          let mulRVV a b = OpsS.mulRVV a b
          let mulVRV a b = OpsS.mulVRV a b
          let cptMul a b = OpsS.cptMulV a b
          let cptMax a b = OpsS.cptMaxV a b
          let cptMin a b = OpsS.cptMinV a b
          let scale a b = OpsS.scaleV a b
          let dot a b = OpsS.dotV a b
          let neg a = OpsS.negV a 
          let transpose a = OpsS.transV a 
          let inplaceAdd a b = OpsS.inplaceAddV a b
          let inplaceSub a b = OpsS.inplaceSubV a b
          let inplace_cptMul a b = OpsS.inplaceCptMulV a b
          let inplace_scale a b = OpsS.inplaceScaleV a b
  
  
  
  
negative.code:         let compare a b = OpsS.compareV a b
          let hash a = OpsS.hashV a
          let inplace_assign  f a = OpsS.assignV f a
          ///Sum of all elements of the vector a
          let sum  (a:Vector<_>) = let ops = a.ElementOps in fold (fun x y -> ops.Add(x,y)) ops.Zero a
          let prod (a:Vector<_>) = let ops = a.ElementOps in fold (fun x y -> ops.Multiply(x,y)) ops.One a
  
          let norm (a:Vector<_>) = 
              let normOps = GenericImpl.getNormOps a.ElementOps 
              sqrt (fold (fun x y -> x + normOps.Norm(y)**2.0) 0.0 a)
  