anchor.diff:  
       override t1.AddTTSlice(location:int[], t2) =
           if not (shapeContains t1.Shape t2.Shape) then failwithf "Expecting t1.Shape to contain t2.Shape, received %A, %A" t1.Shape t2.Shape
  -        let t1value = t1.Value
  +        let t1value = t1.Values
           let t2 = t2 :?> RawTensorFloat32CPU
           let result = Array.copy t1value
           let shape2 = shapeUnsqueezeAs t2.Shape t1.Shape
  
positive.code:             invalidOp <| sprintf "Expecting stride >= 1, received %A" stride
  
      override t.NegT() =
          let result = Array.map (~-) values
          upcast RawTensorFloat32CPU(result, t.Shape)
  
      override t.SumT() =
          let result = Array.reduce (+) values
          upcast RawTensorFloat32CPU([|result|], [||])
      
      override t.SumT2Dim0() =
          if t.Dim <> 2 then invalidOp "Expecting a 2d Tensor"
          let result = Array.init t.Shape.[1] (fun j -> Array.init t.Shape.[0] (fun i -> values.[i * t.Shape.[1] + j]) |> Array.reduce (+))
          let resultShape = [|t.Shape.[1]|]
          upcast RawTensorFloat32CPU(result, resultShape)
  
      override t.TransposeT2() =
          if t.Dim <> 2 then invalidOp "Expecting a 2d Tensor"
          let tcols = t.Shape.[1]
          let result = Array2D.init t.Shape.[1] t.Shape.[0] (fun i j -> values.[j*tcols + i])
          upcast RawTensorFloat32CPU.Create(result)
  
      override t.SqueezeT(dim) =
          let result = Array.copy values
          upcast RawTensorFloat32CPU(result, shapeSqueeze dim t.Shape)
  
      override t.UnsqueezeT(dim) =
          let result = Array.copy values
          upcast RawTensorFloat32CPU(result, shapeUnsqueeze dim t.Shape)
  
      override t.ViewT(shape:int[]) =
          if shapeLength t.Shape <> shapeLength shape then invalidOp <| sprintf "Cannot view Tensor of shape %A as shape %A" t.Shape shape
          let result = Array.copy values
          upcast RawTensorFloat32CPU(result, shape)
  
      override t.SignT() =
          let result = values |> Array.map (sign >> float32)
          upcast RawTensorFloat32CPU(result, t.Shape)
  
      override t.FloorT() =
          let result = values |> Array.map floor
          upcast RawTensorFloat32CPU(result, t.Shape)
  
      override t.CeilT() =
          let result = values |> Array.map ceil
          upcast RawTensorFloat32CPU(result, t.Shape)
  
      override t.RoundT() =
          let result = values |> Array.map round
          upcast RawTensorFloat32CPU(result, t.Shape)
  
      override t.AbsT() =
          let result = values |> Array.map abs
          upcast RawTensorFloat32CPU(result, t.Shape)
  
      override t1.ReluT() =
          let result = t1.Value |> Array.map (max 0.f) 
          upcast RawTensorFloat32CPU(result, t1.Shape)
  
      override t1.SigmoidT() =
          let result = t1.Value |> Array.map (fun v -> 1.f / (1.f + exp -v))
          upcast RawTensorFloat32CPU(result, t1.Shape)
  
      override t.ExpT() =
          let result = values |> Array.map exp
          upcast RawTensorFloat32CPU(result, t.Shape)
  
      override t.LogT() =
          let result = values |> Array.map log
          upcast RawTensorFloat32CPU(result, t.Shape)
  
      override t.Log10T() =
          let result = values |> Array.map log10
          upcast RawTensorFloat32CPU(result, t.Shape)
          
      override t.SqrtT() =
          let result = values |> Array.map sqrt
          upcast RawTensorFloat32CPU(result, t.Shape)
          
      override t.SinT() =
          let result = values |> Array.map sin
          upcast RawTensorFloat32CPU(result, t.Shape)
          
      override t.CosT() =
          let result = values |> Array.map cos
          upcast RawTensorFloat32CPU(result, t.Shape)                
          
      override t.TanT() =
          let result = values |> Array.map tan
          upcast RawTensorFloat32CPU(result, t.Shape)
          
      override t.SinhT() =
          let result = values |> Array.map sinh
          upcast RawTensorFloat32CPU(result, t.Shape)
          
      override t.CoshT() =
          let result = values |> Array.map cosh
          upcast RawTensorFloat32CPU(result, t.Shape)                
          
      override t.TanhT() =
          let result = values |> Array.map tanh
          upcast RawTensorFloat32CPU(result, t.Shape)
  
      override t.AsinT() =
          let result = values |> Array.map asin
          upcast RawTensorFloat32CPU(result, t.Shape)
          
      override t.AcosT() =
          let result = values |> Array.map acos
          upcast RawTensorFloat32CPU(result, t.Shape)                
          
      override t.AtanT() =
          let result = values |> Array.map atan
          upcast RawTensorFloat32CPU(result, t.Shape)
          
  and RawTensorFloat32CPUStatics() = 
  
negative.code:     override probs.RandomMultinomial(numSamples) =
          if probs.Dim < 1 || probs.Dim > 2 then failwithf "Expecting 1d or 2d probs, received shape %A" probs.Shape
          if probs.Dim = 1 then
              let p = probs.Values |> Array.map float
              let result = [|for i=0 to numSamples-1 do yield float32 (Random.ChoiceIndex(p))|]
              upcast RawTensorFloat32CPU(result, [|numSamples|])
          else
  