anchor.diff:          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)
  
positive.code:     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
      let ofArray arr : vector = VG.ofArray arr
      let toArray (m : vector) = VG.toArray m
  
      type range = int * int
      let countR ((a,b) : range)   = (b-a)+1
  
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
      
      
  