anchor.diff:      member a.round() =
           let inline fRaw(a:RawTensor) = a.RoundT()
           let inline fTensor(a:Tensor) = a.round()
  -        let inline dfTensorFwd(ap,ad,cp:Tensor) = cp.zerosLike()
  -        let inline dfTensorRev(a) = RoundT(a)
  -        Tensor.OpUnary(a, fRaw, fTensor, dfTensorFwd, dfTensorRev)
  +        let inline dfFwd(ap,ad,fp:Tensor) = fp.zerosLike()
  +        let inline dfRev(a) = RoundT(a)
  +        Tensor.OpUnary(a, fRaw, fTensor, dfFwd, dfRev)
   
       /// <summary>A method to enable the use of the F# function <c>round</c>.</summary>
       static member Round(a:Tensor) = a.round() // needed for FSharp.Core round operator overload
  
positive.code:         Shape.checkCanFlip a.dim dims
          let inline fRaw(a:RawTensor) = a.FlipT(dims)
          let inline fTensor(a:Tensor) = a.flip(dims)
          let inline dfTensorFwd(ap,ad:Tensor,cp) = ad.flip(dims)
          let inline dfTensorRev(a) = FlipT(a, dims)
          Tensor.OpUnary(a, fRaw, fTensor, dfTensorFwd, dfTensorRev)
  
      /// <summary>Dilate the tensor in using the given dilations in each corresponding dimension.</summary>
      /// <param name="dilations">The dilations to use.</param>
  
negative.code:         Shape.checkCanMaxunpool3d a.dtype a.shape indices.dtype indices.shape outputSize |> ignore
          let inline fRaw(a:RawTensor) = a.MaxUnpool3D(indices.primalRaw, outputSize)
          let inline fTensor(a:Tensor) = a.maxunpool3d(indices, kernelSizes=kernelSizes, strides=strides, paddings=paddings, outputSize=outputSize)
          let inline dfFwd(ap:Tensor,ad:Tensor,fp:Tensor) = ad.maxunpool3d(indices, kernelSizes=kernelSizes, strides=strides, paddings=paddings, outputSize=outputSize)
          let inline dfRev(a) = MaxUnpool3DT(a, indices)
          Tensor.OpUnary(a, fRaw, fTensor, dfFwd, dfRev)
  
      /// <summary>Applies a 1D convolution over an input signal composed of several input planes</summary>
      /// <param name="filters">The filters.</param>
  