anchor.diff:              invalidOp <| sprintf "Expecting stride >= 1, received %A" stride
   
       override t.NegT() =
  -        let result = Array.map (~-) values
  +        let result = Array.map (~-) t.Values
           upcast RawTensorFloat32CPU(result, t.Shape)
   
       override t.SumT() =
  -        let result = Array.reduce (+) values
  +        let result = Array.reduce (+) t.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 result = Array.init t.Shape.[1] (fun j -> Array.init t.Shape.[0] (fun i -> t.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])
  +        let result = Array2D.init t.Shape.[1] t.Shape.[0] (fun i j -> t.Values.[j*tcols + i])
           upcast RawTensorFloat32CPU.Create(result)
   
       override t.SqueezeT(dim) =
  -        let result = Array.copy values
  +        let result = Array.copy t.Values
           upcast RawTensorFloat32CPU(result, shapeSqueeze dim t.Shape)
   
       override t.UnsqueezeT(dim) =
  -        let result = Array.copy values
  +        let result = Array.copy t.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
  +        let result = Array.copy t.Values
           upcast RawTensorFloat32CPU(result, shape)
   
       override t.SignT() =
  -        let result = values |> Array.map (sign >> float32)
  +        let result = t.Values |> Array.map (sign >> float32)
           upcast RawTensorFloat32CPU(result, t.Shape)
   
       override t.FloorT() =
  -        let result = values |> Array.map floor
  +        let result = t.Values |> Array.map floor
           upcast RawTensorFloat32CPU(result, t.Shape)
   
       override t.CeilT() =
  -        let result = values |> Array.map ceil
  +        let result = t.Values |> Array.map ceil
           upcast RawTensorFloat32CPU(result, t.Shape)
   
       override t.RoundT() =
  -        let result = values |> Array.map round
  +        let result = t.Values |> Array.map round
           upcast RawTensorFloat32CPU(result, t.Shape)
   
       override t.AbsT() =
  -        let result = values |> Array.map abs
  +        let result = t.Values |> Array.map abs
           upcast RawTensorFloat32CPU(result, t.Shape)
   
       override t1.ReluT() =
  -        let result = t1.Value |> Array.map (max 0.f) 
  +        let result = t1.Values |> 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))
  +        let result = t1.Values |> Array.map (fun v -> 1.f / (1.f + exp -v))
           upcast RawTensorFloat32CPU(result, t1.Shape)
   
       override t.ExpT() =
  -        let result = values |> Array.map exp
  +        let result = t.Values |> Array.map exp
           upcast RawTensorFloat32CPU(result, t.Shape)
   
       override t.LogT() =
  -        let result = values |> Array.map log
  +        let result = t.Values |> Array.map log
           upcast RawTensorFloat32CPU(result, t.Shape)
   
       override t.Log10T() =
  -        let result = values |> Array.map log10
  +        let result = t.Values |> Array.map log10
           upcast RawTensorFloat32CPU(result, t.Shape)
           
       override t.SqrtT() =
  -        let result = values |> Array.map sqrt
  +        let result = t.Values |> Array.map sqrt
           upcast RawTensorFloat32CPU(result, t.Shape)
           
       override t.SinT() =
  -        let result = values |> Array.map sin
  +        let result = t.Values |> Array.map sin
           upcast RawTensorFloat32CPU(result, t.Shape)
           
       override t.CosT() =
  -        let result = values |> Array.map cos
  +        let result = t.Values |> Array.map cos
           upcast RawTensorFloat32CPU(result, t.Shape)                
           
       override t.TanT() =
  -        let result = values |> Array.map tan
  +        let result = t.Values |> Array.map tan
           upcast RawTensorFloat32CPU(result, t.Shape)
           
       override t.SinhT() =
  -        let result = values |> Array.map sinh
  +        let result = t.Values |> Array.map sinh
           upcast RawTensorFloat32CPU(result, t.Shape)
           
       override t.CoshT() =
  -        let result = values |> Array.map cosh
  +        let result = t.Values |> Array.map cosh
           upcast RawTensorFloat32CPU(result, t.Shape)                
           
       override t.TanhT() =
  -        let result = values |> Array.map tanh
  +        let result = t.Values |> Array.map tanh
           upcast RawTensorFloat32CPU(result, t.Shape)
   
       override t.AsinT() =
  -        let result = values |> Array.map asin
  +        let result = t.Values |> Array.map asin
           upcast RawTensorFloat32CPU(result, t.Shape)
           
       override t.AcosT() =
  -        let result = values |> Array.map acos
  +        let result = t.Values |> Array.map acos
           upcast RawTensorFloat32CPU(result, t.Shape)                
           
       override t.AtanT() =
  -        let result = values |> Array.map atan
  +        let result = t.Values |> Array.map atan
           upcast RawTensorFloat32CPU(result, t.Shape)
           
   and RawTensorFloat32CPUStatics() = 
  
positive.code: type RawTensorFloat32CPU(values: float32[], shape:int[]) =
      inherit RawTensor(shape, Float32, CPU, DiffSharp.Backend.Backend.None)
  
      member __.Value = values
  
      static member Zero() =
          let values = [|0.f|]
  
negative.code:         upcast RawTensorFloat32CPU(result, t1.Shape)
  
      override t1.SubTT(t2) =
          let t1value = t1.Values
          let t2value = (t2 :?> RawTensorFloat32CPU).Values
          let result = Array.map2 (-) t1value t2value
          upcast RawTensorFloat32CPU(result, t1.Shape)
  
      override t1.SubT0T(t2) =
          let t1value = t1.Values.[0]
          let t2value = (t2 :?> RawTensorFloat32CPU).Values
          let result = Array.map ((-) t1value) t2value
          upcast RawTensorFloat32CPU(result, t2.Shape)
  
      override t1.SubTT0(t2) =
          let t1value = t1.Values
          let t2value = (t2 :?> RawTensorFloat32CPU).Values.[0]
          let result = Array.map (fun t -> t - t2value) t1value
          upcast RawTensorFloat32CPU(result, t1.Shape)
  
      override t1.MulTT(t2) =
          let t1value = t1.Values
          let t2value = (t2 :?> RawTensorFloat32CPU).Values
          let result = Array.map2 (*) t1value t2value
          upcast RawTensorFloat32CPU(result, t1.Shape)
  
      override t1.MulTT0(t2) =
          let t1value = t1.Values
          let t2value = (t2 :?> RawTensorFloat32CPU).Values.[0]
          let result = Array.map ((*) t2value) t1value
          upcast RawTensorFloat32CPU(result, t1.Shape)
  
      override t1.DivTT(t2) =
          let t1value = t1.Values
          let t2value = (t2 :?> RawTensorFloat32CPU).Values
          let result = Array.map2 (/) t1value t2value
          upcast RawTensorFloat32CPU(result, t1.Shape)
  
      override t1.DivT0T(t2) =
          let t1value = t1.Values.[0]
          let t2value = (t2 :?> RawTensorFloat32CPU).Values
          let result = Array.map ((/) t1value) t2value
          upcast RawTensorFloat32CPU(result, t2.Shape)
  
      override t1.DivTT0(t2) =
          let t1value = t1.Values
          let t2value = (t2 :?> RawTensorFloat32CPU).Values.[0]
          let result = Array.map (fun t -> t / t2value) t1value
          upcast RawTensorFloat32CPU(result, t1.Shape)
  
      override t1.PowTT(t2) =
          let t1value = t1.Values
          let t2value = (t2 :?> RawTensorFloat32CPU).Values
          let result = Array.map2 ( ** ) t1value t2value
          upcast RawTensorFloat32CPU(result, t1.Shape)
  
      override t1.PowT0T(t2) =
          let t1value = t1.Values.[0]
          let t2value = (t2 :?> RawTensorFloat32CPU).Values
          let result = Array.map (fun t -> t1value ** t) t2value
          upcast RawTensorFloat32CPU(result, t2.Shape)
  
      override t1.PowTT0(t2) =
          let t1value = t1.Values
          let t2value = (t2 :?> RawTensorFloat32CPU).Values.[0]
          let result = Array.map (fun t -> t ** t2value) t1value
          upcast RawTensorFloat32CPU(result, t1.Shape)
  
  