anchor.diff:      module VG = Generic
       module VecDS = DoubleImpl
       module VecGU = GenericImpl
  -
  -    let get (a:vector) j   = VG.get a j 
  -    let set (a:vector) j x = VG.set a j x
  -    let length (a:vector)     = VG.length a
  -    let nrows (a:vector)   = VG.length a
  -    let init  m   f = VecDS.createVecDS  m   f
  +    ///Returns the value of the vector a at the given index j
  +    let get (v:vector) j   = VG.get v j 
  +    ///Sets the value x to the vector a at the given index j
  +    let set (v:vector) j x = VG.set v j x
  +    ///Returns length of vector a
  +    let length (v:vector)     = VG.length v
  +    ///Returns length of vector a
  +    let nrows (v:vector)   = VG.length v
  +    ///Initiates vector of length m and fills it by applying function f on indices
  +    let init  i   f = VecDS.createVecDS  i   f
  +    ///Creates vector with values of array arr
       let ofArray arr : vector = VG.ofArray arr
  -    let toArray (m : vector) = VG.toArray m
  +    ///Creates array with values of vector m
  +    let toArray (v : vector) = VG.toArray v
   
       type range = int * int
       let countR ((a,b) : range)   = (b-a)+1
  
positive.code:         let compare a b = OpsS.compareV a b
          let hash a = OpsS.hashV a
          let inplace_assign  f a = OpsS.assignV f 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)
  
negative.code:     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
      
      
  